]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxICOHandler swig_types[53]
2516 #define SWIGTYPE_p_wxIconizeEvent swig_types[54]
2517 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
2518 #define SWIGTYPE_p_wxImage swig_types[56]
2519 #define SWIGTYPE_p_wxImageHandler swig_types[57]
2520 #define SWIGTYPE_p_wxImageHistogram swig_types[58]
2521 #define SWIGTYPE_p_wxImage_HSVValue swig_types[59]
2522 #define SWIGTYPE_p_wxImage_RGBValue swig_types[60]
2523 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[61]
2524 #define SWIGTYPE_p_wxInitDialogEvent swig_types[62]
2525 #define SWIGTYPE_p_wxInputStream swig_types[63]
2526 #define SWIGTYPE_p_wxInternetFSHandler swig_types[64]
2527 #define SWIGTYPE_p_wxItemContainer swig_types[65]
2528 #define SWIGTYPE_p_wxJPEGHandler swig_types[66]
2529 #define SWIGTYPE_p_wxKeyEvent swig_types[67]
2530 #define SWIGTYPE_p_wxLayoutConstraints swig_types[68]
2531 #define SWIGTYPE_p_wxMaximizeEvent swig_types[69]
2532 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
2533 #define SWIGTYPE_p_wxMenu swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBar swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBarBase swig_types[73]
2536 #define SWIGTYPE_p_wxMenuEvent swig_types[74]
2537 #define SWIGTYPE_p_wxMenuItem swig_types[75]
2538 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMouseEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMoveEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNcPaintEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNotifyEvent swig_types[81]
2544 #define SWIGTYPE_p_wxObject swig_types[82]
2545 #define SWIGTYPE_p_wxOutputStream swig_types[83]
2546 #define SWIGTYPE_p_wxPCXHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNGHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNMHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPaintEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaperSize swig_types[89]
2552 #define SWIGTYPE_p_wxPoint swig_types[90]
2553 #define SWIGTYPE_p_wxPoint2D swig_types[91]
2554 #define SWIGTYPE_p_wxPropagateOnce swig_types[92]
2555 #define SWIGTYPE_p_wxPropagationDisabler swig_types[93]
2556 #define SWIGTYPE_p_wxPyApp swig_types[94]
2557 #define SWIGTYPE_p_wxPyCommandEvent swig_types[95]
2558 #define SWIGTYPE_p_wxPyDropTarget swig_types[96]
2559 #define SWIGTYPE_p_wxPyEvent swig_types[97]
2560 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyImageHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyInputStream swig_types[100]
2563 #define SWIGTYPE_p_wxPySizer swig_types[101]
2564 #define SWIGTYPE_p_wxPyValidator swig_types[102]
2565 #define SWIGTYPE_p_wxQuantize swig_types[103]
2566 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[104]
2567 #define SWIGTYPE_p_wxRealPoint swig_types[105]
2568 #define SWIGTYPE_p_wxRect swig_types[106]
2569 #define SWIGTYPE_p_wxRegion swig_types[107]
2570 #define SWIGTYPE_p_wxScrollEvent swig_types[108]
2571 #define SWIGTYPE_p_wxScrollWinEvent swig_types[109]
2572 #define SWIGTYPE_p_wxSetCursorEvent swig_types[110]
2573 #define SWIGTYPE_p_wxShowEvent swig_types[111]
2574 #define SWIGTYPE_p_wxSize swig_types[112]
2575 #define SWIGTYPE_p_wxSizeEvent swig_types[113]
2576 #define SWIGTYPE_p_wxSizer swig_types[114]
2577 #define SWIGTYPE_p_wxSizerItem swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBox swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[117]
2580 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[118]
2581 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[119]
2582 #define SWIGTYPE_p_wxTIFFHandler swig_types[120]
2583 #define SWIGTYPE_p_wxToolTip swig_types[121]
2584 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[122]
2585 #define SWIGTYPE_p_wxValidator swig_types[123]
2586 #define SWIGTYPE_p_wxVisualAttributes swig_types[124]
2587 #define SWIGTYPE_p_wxWindow swig_types[125]
2588 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[126]
2589 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[127]
2590 #define SWIGTYPE_p_wxXPMHandler swig_types[128]
2591 #define SWIGTYPE_p_wxZipFSHandler swig_types[129]
2592 static swig_type_info *swig_types[131];
2593 static swig_module_info swig_module = {swig_types, 130, 0, 0, 0, 0};
2594 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2595 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2596
2597 /* -------- TYPES TABLE (END) -------- */
2598
2599 #if (PY_VERSION_HEX <= 0x02000000)
2600 # if !defined(SWIG_PYTHON_CLASSIC)
2601 # error "This python version requires to use swig with the '-classic' option"
2602 # endif
2603 #endif
2604 #if (PY_VERSION_HEX <= 0x02020000)
2605 # error "This python version requires to use swig with the '-nomodern' option"
2606 #endif
2607 #if (PY_VERSION_HEX <= 0x02020000)
2608 # error "This python version requires to use swig with the '-nomodernargs' option"
2609 #endif
2610 #ifndef METH_O
2611 # error "This python version requires to use swig with the '-nofastunpack' option"
2612 #endif
2613
2614 /*-----------------------------------------------
2615 @(target):= _core_.so
2616 ------------------------------------------------*/
2617 #define SWIG_init init_core_
2618
2619 #define SWIG_name "_core_"
2620
2621 #define SWIGVERSION 0x010329
2622
2623
2624 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2625 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2626
2627
2628 #include <stdexcept>
2629
2630
2631 namespace swig {
2632 class PyObject_ptr {
2633 protected:
2634 PyObject *_obj;
2635
2636 public:
2637 PyObject_ptr() :_obj(0)
2638 {
2639 }
2640
2641 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2642 {
2643 Py_XINCREF(_obj);
2644 }
2645
2646 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2647 {
2648 if (initial_ref) Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr & operator=(const PyObject_ptr& item)
2652 {
2653 Py_XINCREF(item._obj);
2654 Py_XDECREF(_obj);
2655 _obj = item._obj;
2656 return *this;
2657 }
2658
2659 ~PyObject_ptr()
2660 {
2661 Py_XDECREF(_obj);
2662 }
2663
2664 operator PyObject *() const
2665 {
2666 return _obj;
2667 }
2668
2669 PyObject *operator->() const
2670 {
2671 return _obj;
2672 }
2673 };
2674 }
2675
2676
2677 namespace swig {
2678 struct PyObject_var : PyObject_ptr {
2679 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2680
2681 PyObject_var & operator = (PyObject* obj)
2682 {
2683 Py_XDECREF(_obj);
2684 _obj = obj;
2685 return *this;
2686 }
2687 };
2688 }
2689
2690
2691 #include "wx/wxPython/wxPython_int.h"
2692 #include "wx/wxPython/pyclasses.h"
2693 #include "wx/wxPython/twoitem.h"
2694
2695
2696 #ifndef wxPyUSE_EXPORT
2697 // Helper functions for dealing with SWIG objects and such. These are
2698 // located here so they know about the SWIG types and functions declared
2699 // in the wrapper code.
2700
2701 #include <wx/hashmap.h>
2702 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2703
2704
2705 // Maintains a hashmap of className to swig_type_info pointers. Given the
2706 // name of a class either looks up the type info in the cache, or scans the
2707 // SWIG tables for it.
2708 extern PyObject* wxPyPtrTypeMap;
2709 static
2710 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2711
2712 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2713
2714 if (typeInfoCache == NULL)
2715 typeInfoCache = new wxPyTypeInfoHashMap;
2716
2717 wxString name(className);
2718 swig_type_info* swigType = (*typeInfoCache)[name];
2719
2720 if (! swigType) {
2721 // it wasn't in the cache, so look it up from SWIG
2722 name.Append(wxT(" *"));
2723 swigType = SWIG_TypeQuery(name.mb_str());
2724
2725 // if it still wasn't found, try looking for a mapped name
2726 if (!swigType) {
2727 PyObject* item;
2728 name = className;
2729
2730 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2731 (char*)(const char*)name.mbc_str())) != NULL) {
2732 name = wxString(PyString_AsString(item), *wxConvCurrent);
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735 }
2736 }
2737 if (swigType) {
2738 // and add it to the map if found
2739 (*typeInfoCache)[className] = swigType;
2740 }
2741 }
2742 return swigType;
2743 }
2744
2745
2746 // Check if a class name is a type known to SWIG
2747 bool wxPyCheckSwigType(const wxChar* className) {
2748
2749 swig_type_info* swigType = wxPyFindSwigType(className);
2750 return swigType != NULL;
2751 }
2752
2753
2754 // Given a pointer to a C++ object and a class name, construct a Python proxy
2755 // object for it.
2756 PyObject* wxPyConstructObject(void* ptr,
2757 const wxChar* className,
2758 int setThisOwn) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2762
2763 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2764 }
2765
2766
2767 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2768 // Ensures that the proxy object is of the specified (or derived) type. If
2769 // not able to perform the conversion then a Python exception is set and the
2770 // error should be handled properly in the caller. Returns True on success.
2771 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2772 const wxChar* className) {
2773
2774 swig_type_info* swigType = wxPyFindSwigType(className);
2775 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2776
2777 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2778 }
2779
2780
2781
2782 // Make a SWIGified pointer object suitable for a .this attribute
2783 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2784
2785 PyObject* robj = NULL;
2786
2787 swig_type_info* swigType = wxPyFindSwigType(className);
2788 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2789
2790 robj = PySwigObject_New(ptr, swigType, 0);
2791 return robj;
2792 }
2793
2794
2795 // Python's PyInstance_Check does not return True for instances of new-style
2796 // classes. This should get close enough for both new and old classes but I
2797 // should re-evaluate the need for doing instance checks...
2798 bool wxPyInstance_Check(PyObject* obj) {
2799 return PyObject_HasAttrString(obj, "__class__") != 0;
2800 }
2801
2802
2803 // This one checks if the object is an instance of a SWIG proxy class (it has
2804 // a .this attribute, and the .this attribute is a PySwigObject.)
2805 bool wxPySwigInstance_Check(PyObject* obj) {
2806 static PyObject* this_str = NULL;
2807 if (this_str == NULL)
2808 this_str = PyString_FromString("this");
2809
2810 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2811 if (this_attr) {
2812 bool retval = (PySwigObject_Check(this_attr) != 0);
2813 Py_DECREF(this_attr);
2814 return retval;
2815 }
2816
2817 PyErr_Clear();
2818 return false;
2819 }
2820
2821
2822 // Export a C API in a struct. Other modules will be able to load this from
2823 // the wx._core_ module and will then have safe access to these functions,
2824 // even if they are located in another shared library.
2825 static wxPyCoreAPI API = {
2826
2827 wxPyCheckSwigType,
2828 wxPyConstructObject,
2829 wxPyConvertSwigPtr,
2830 wxPyMakeSwigPtr,
2831
2832 wxPyBeginAllowThreads,
2833 wxPyEndAllowThreads,
2834 wxPyBeginBlockThreads,
2835 wxPyEndBlockThreads,
2836
2837 wxPy_ConvertList,
2838
2839 wxString_in_helper,
2840 Py2wxString,
2841 wx2PyString,
2842
2843 byte_LIST_helper,
2844 int_LIST_helper,
2845 long_LIST_helper,
2846 string_LIST_helper,
2847 wxPoint_LIST_helper,
2848 wxBitmap_LIST_helper,
2849 wxString_LIST_helper,
2850 wxAcceleratorEntry_LIST_helper,
2851
2852 wxSize_helper,
2853 wxPoint_helper,
2854 wxRealPoint_helper,
2855 wxRect_helper,
2856 wxColour_helper,
2857 wxPoint2D_helper,
2858
2859 wxPySimple_typecheck,
2860 wxColour_typecheck,
2861
2862 wxPyCBH_setCallbackInfo,
2863 wxPyCBH_findCallback,
2864 wxPyCBH_callCallback,
2865 wxPyCBH_callCallbackObj,
2866 wxPyCBH_delete,
2867
2868 wxPyMake_wxObject,
2869 wxPyMake_wxSizer,
2870 wxPyPtrTypeMap_Add,
2871 wxPy2int_seq_helper,
2872 wxPy4int_seq_helper,
2873 wxArrayString2PyList_helper,
2874 wxArrayInt2PyList_helper,
2875
2876 wxPyClientData_dtor,
2877 wxPyUserData_dtor,
2878 wxPyOORClientData_dtor,
2879
2880 wxPyCBInputStream_create,
2881 wxPyCBInputStream_copy,
2882
2883 wxPyInstance_Check,
2884 wxPySwigInstance_Check,
2885
2886 wxPyCheckForApp
2887
2888 };
2889
2890 #endif
2891
2892
2893 #if !WXWIN_COMPATIBILITY_2_4
2894 #define wxHIDE_READONLY 0
2895 #endif
2896
2897
2898 #define SWIG_From_long PyInt_FromLong
2899
2900
2901 SWIGINTERNINLINE PyObject *
2902 SWIG_From_int (int value)
2903 {
2904 return SWIG_From_long (value);
2905 }
2906
2907 static const wxString wxPyEmptyString(wxEmptyString);
2908 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2909 return self->GetClassInfo()->GetClassName();
2910 }
2911 SWIGINTERN void wxObject_Destroy(wxObject *self){
2912 delete self;
2913 }
2914
2915 #ifndef __WXMAC__
2916 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2917 #endif
2918
2919
2920 #include <limits.h>
2921 #ifndef LLONG_MIN
2922 # define LLONG_MIN LONG_LONG_MIN
2923 #endif
2924 #ifndef LLONG_MAX
2925 # define LLONG_MAX LONG_LONG_MAX
2926 #endif
2927 #ifndef ULLONG_MAX
2928 # define ULLONG_MAX ULONG_LONG_MAX
2929 #endif
2930
2931
2932 SWIGINTERN int
2933 SWIG_AsVal_long (PyObject* obj, long* val)
2934 {
2935 if (PyNumber_Check(obj)) {
2936 if (val) *val = PyInt_AsLong(obj);
2937 return SWIG_OK;
2938 }
2939 return SWIG_TypeError;
2940 }
2941
2942
2943 SWIGINTERN int
2944 SWIG_AsVal_int (PyObject * obj, int *val)
2945 {
2946 long v;
2947 int res = SWIG_AsVal_long (obj, &v);
2948 if (SWIG_IsOK(res)) {
2949 if ((v < INT_MIN || v > INT_MAX)) {
2950 return SWIG_OverflowError;
2951 } else {
2952 if (val) *val = static_cast< int >(v);
2953 }
2954 }
2955 return res;
2956 }
2957
2958 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2959 wxSize temp, *obj = &temp;
2960 if ( other == Py_None ) return false;
2961 if ( ! wxSize_helper(other, &obj) ) {
2962 PyErr_Clear();
2963 return false;
2964 }
2965 return self->operator==(*obj);
2966 }
2967 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2968 wxSize temp, *obj = &temp;
2969 if ( other == Py_None ) return true;
2970 if ( ! wxSize_helper(other, &obj)) {
2971 PyErr_Clear();
2972 return true;
2973 }
2974 return self->operator!=(*obj);
2975 }
2976 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2977 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2978 PyObject* tup = PyTuple_New(2);
2979 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2980 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2981 wxPyEndBlockThreads(blocked);
2982 return tup;
2983 }
2984
2985 SWIGINTERN int
2986 SWIG_AsVal_double (PyObject *obj, double* val)
2987 {
2988 if (PyNumber_Check(obj)) {
2989 if (val) *val = PyFloat_AsDouble(obj);
2990 return SWIG_OK;
2991 }
2992 return SWIG_TypeError;
2993 }
2994
2995
2996 #define SWIG_From_double PyFloat_FromDouble
2997
2998 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2999 wxRealPoint temp, *obj = &temp;
3000 if ( other == Py_None ) return false;
3001 if ( ! wxRealPoint_helper(other, &obj) ) {
3002 PyErr_Clear();
3003 return false;
3004 }
3005 return self->operator==(*obj);
3006 }
3007 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3008 wxRealPoint temp, *obj = &temp;
3009 if ( other == Py_None ) return true;
3010 if ( ! wxRealPoint_helper(other, &obj)) {
3011 PyErr_Clear();
3012 return true;
3013 }
3014 return self->operator!=(*obj);
3015 }
3016 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3017 self->x = x;
3018 self->y = y;
3019 }
3020 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3021 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3022 PyObject* tup = PyTuple_New(2);
3023 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3024 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3025 wxPyEndBlockThreads(blocked);
3026 return tup;
3027 }
3028 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3029 wxPoint temp, *obj = &temp;
3030 if ( other == Py_None ) return false;
3031 if ( ! wxPoint_helper(other, &obj) ) {
3032 PyErr_Clear();
3033 return false;
3034 }
3035 return self->operator==(*obj);
3036 }
3037 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3038 wxPoint temp, *obj = &temp;
3039 if ( other == Py_None ) return true;
3040 if ( ! wxPoint_helper(other, &obj)) {
3041 PyErr_Clear();
3042 return true;
3043 }
3044 return self->operator!=(*obj);
3045 }
3046 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3047 self->x = x;
3048 self->y = y;
3049 }
3050 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3052 PyObject* tup = PyTuple_New(2);
3053 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3054 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3055 wxPyEndBlockThreads(blocked);
3056 return tup;
3057 }
3058 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3059 wxRect temp, *obj = &temp;
3060 if ( other == Py_None ) return false;
3061 if ( ! wxRect_helper(other, &obj) ) {
3062 PyErr_Clear();
3063 return false;
3064 }
3065 return self->operator==(*obj);
3066 }
3067 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3068 wxRect temp, *obj = &temp;
3069 if ( other == Py_None ) return true;
3070 if ( ! wxRect_helper(other, &obj)) {
3071 PyErr_Clear();
3072 return true;
3073 }
3074 return self->operator!=(*obj);
3075 }
3076 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3077 self->x = x;
3078 self->y = y;
3079 self->width = width;
3080 self->height = height;
3081 }
3082 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(4);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3088 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3089 wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092
3093 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3094 wxRegion reg1(*r1);
3095 wxRegion reg2(*r2);
3096 wxRect dest(0,0,0,0);
3097 PyObject* obj;
3098
3099 reg1.Intersect(reg2);
3100 dest = reg1.GetBox();
3101
3102 if (dest != wxRect(0,0,0,0)) {
3103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3104 wxRect* newRect = new wxRect(dest);
3105 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3106 wxPyEndBlockThreads(blocked);
3107 return obj;
3108 }
3109 Py_INCREF(Py_None);
3110 return Py_None;
3111 }
3112
3113 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3114 wxPoint2D temp, *obj = &temp;
3115 if ( other == Py_None ) return false;
3116 if ( ! wxPoint2D_helper(other, &obj) ) {
3117 PyErr_Clear();
3118 return false;
3119 }
3120 return self->operator==(*obj);
3121 }
3122 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3123 wxPoint2D temp, *obj = &temp;
3124 if ( other == Py_None ) return true;
3125 if ( ! wxPoint2D_helper(other, &obj)) {
3126 PyErr_Clear();
3127 return true;
3128 }
3129 return self->operator!=(*obj);
3130 }
3131 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3132 self->m_x = x;
3133 self->m_y = y;
3134 }
3135 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 PyObject* tup = PyTuple_New(2);
3138 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3139 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3140 wxPyEndBlockThreads(blocked);
3141 return tup;
3142 }
3143
3144 #include "wx/wxPython/pyistream.h"
3145
3146 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3147 wxInputStream* wxis = wxPyCBInputStream::create(p);
3148 if (wxis)
3149 return new wxPyInputStream(wxis);
3150 else
3151 return NULL;
3152 }
3153
3154 SWIGINTERN swig_type_info*
3155 SWIG_pchar_descriptor()
3156 {
3157 static int init = 0;
3158 static swig_type_info* info = 0;
3159 if (!init) {
3160 info = SWIG_TypeQuery("_p_char");
3161 init = 1;
3162 }
3163 return info;
3164 }
3165
3166
3167 SWIGINTERNINLINE PyObject *
3168 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3169 {
3170 if (carray) {
3171 if (size > INT_MAX) {
3172 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3173 return pchar_descriptor ?
3174 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3175 } else {
3176 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3177 }
3178 } else {
3179 return SWIG_Py_Void();
3180 }
3181 }
3182
3183
3184 SWIGINTERNINLINE PyObject *
3185 SWIG_From_char (char c)
3186 {
3187 return SWIG_FromCharPtrAndSize(&c,1);
3188 }
3189
3190
3191 SWIGINTERNINLINE PyObject*
3192 SWIG_From_unsigned_SS_long (unsigned long value)
3193 {
3194 return (value > LONG_MAX) ?
3195 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3196 }
3197
3198
3199 SWIGINTERNINLINE PyObject *
3200 SWIG_From_size_t (size_t value)
3201 {
3202 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3203 }
3204
3205
3206 SWIGINTERN int
3207 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3208 {
3209 if (PyString_Check(obj)) {
3210 char *cstr; int len;
3211 PyString_AsStringAndSize(obj, &cstr, &len);
3212 if (cptr) {
3213 if (alloc) {
3214 /*
3215 In python the user should not be able to modify the inner
3216 string representation. To warranty that, if you define
3217 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3218 buffer is always returned.
3219
3220 The default behavior is just to return the pointer value,
3221 so, be careful.
3222 */
3223 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3224 if (*alloc != SWIG_OLDOBJ)
3225 #else
3226 if (*alloc == SWIG_NEWOBJ)
3227 #endif
3228 {
3229 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3230 *alloc = SWIG_NEWOBJ;
3231 }
3232 else {
3233 *cptr = cstr;
3234 *alloc = SWIG_OLDOBJ;
3235 }
3236 } else {
3237 *cptr = PyString_AsString(obj);
3238 }
3239 }
3240 if (psize) *psize = len + 1;
3241 return SWIG_OK;
3242 } else {
3243 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3244 if (pchar_descriptor) {
3245 void* vptr = 0;
3246 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3247 if (cptr) *cptr = (char *) vptr;
3248 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3249 if (alloc) *alloc = SWIG_OLDOBJ;
3250 return SWIG_OK;
3251 }
3252 }
3253 }
3254 return SWIG_TypeError;
3255 }
3256
3257
3258 SWIGINTERN int
3259 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3260 {
3261 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3262 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3263 if (SWIG_IsOK(res)) {
3264 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3265 if (csize <= size) {
3266 if (val) {
3267 if (csize) memcpy(val, cptr, csize*sizeof(char));
3268 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3269 }
3270 if (alloc == SWIG_NEWOBJ) {
3271 delete[] cptr;
3272 res = SWIG_DelNewMask(res);
3273 }
3274 return res;
3275 }
3276 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3277 }
3278 return SWIG_TypeError;
3279 }
3280
3281
3282 SWIGINTERN int
3283 SWIG_AsVal_char (PyObject * obj, char *val)
3284 {
3285 int res = SWIG_AsCharArray(obj, val, 1);
3286 if (!SWIG_IsOK(res)) {
3287 long v;
3288 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3289 if (SWIG_IsOK(res)) {
3290 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3291 if (val) *val = static_cast< char >(v);
3292 } else {
3293 res = SWIG_OverflowError;
3294 }
3295 }
3296 }
3297 return res;
3298 }
3299
3300 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3301 // We use only strings for the streams, not unicode
3302 PyObject* str = PyObject_Str(obj);
3303 if (! str) {
3304 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3305 return;
3306 }
3307 self->Write(PyString_AS_STRING(str),
3308 PyString_GET_SIZE(str));
3309 Py_DECREF(str);
3310 }
3311
3312 #include "wx/wxPython/pyistream.h"
3313
3314
3315 class wxPyFileSystemHandler : public wxFileSystemHandler
3316 {
3317 public:
3318 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3319
3320 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3321 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3322 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3323 DEC_PYCALLBACK_STRING__pure(FindNext);
3324
3325 wxString GetProtocol(const wxString& location) {
3326 return wxFileSystemHandler::GetProtocol(location);
3327 }
3328
3329 wxString GetLeftLocation(const wxString& location) {
3330 return wxFileSystemHandler::GetLeftLocation(location);
3331 }
3332
3333 wxString GetAnchor(const wxString& location) {
3334 return wxFileSystemHandler::GetAnchor(location);
3335 }
3336
3337 wxString GetRightLocation(const wxString& location) {
3338 return wxFileSystemHandler::GetRightLocation(location);
3339 }
3340
3341 wxString GetMimeTypeFromExt(const wxString& location) {
3342 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3343 }
3344
3345 PYPRIVATE;
3346 };
3347
3348
3349 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3350 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3351 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3352 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3353
3354
3355 SWIGINTERN int
3356 SWIG_AsVal_bool (PyObject *obj, bool *val)
3357 {
3358 if (obj == Py_True) {
3359 if (val) *val = true;
3360 return SWIG_OK;
3361 } else if (obj == Py_False) {
3362 if (val) *val = false;
3363 return SWIG_OK;
3364 } else {
3365 long v = 0;
3366 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3367 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3368 return res;
3369 }
3370 }
3371
3372 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3373 wxFileName fname = wxFileSystem::URLToFileName(url);
3374 return fname.GetFullPath();
3375 }
3376
3377 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3378 wxImage& image,
3379 long type) {
3380 wxMemoryFSHandler::AddFile(filename, image, type);
3381 }
3382
3383 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3384 const wxBitmap& bitmap,
3385 long type) {
3386 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3387 }
3388
3389 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3390 PyObject* data) {
3391 if (! PyString_Check(data)) {
3392 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3393 "Expected string object"));
3394 return;
3395 }
3396
3397 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3398 void* ptr = (void*)PyString_AsString(data);
3399 size_t size = PyString_Size(data);
3400 wxPyEndBlockThreads(blocked);
3401
3402 wxMemoryFSHandler::AddFile(filename, ptr, size);
3403 }
3404
3405
3406 #include "wx/wxPython/pyistream.h"
3407
3408
3409 SWIGINTERN int
3410 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3411 {
3412 long v = 0;
3413 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3414 return SWIG_TypeError;
3415 }
3416 else if (val)
3417 *val = (unsigned long)v;
3418 return SWIG_OK;
3419 }
3420
3421
3422 SWIGINTERN int
3423 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3424 {
3425 unsigned long v;
3426 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3427 if (SWIG_IsOK(res)) {
3428 if ((v > UCHAR_MAX)) {
3429 return SWIG_OverflowError;
3430 } else {
3431 if (val) *val = static_cast< unsigned char >(v);
3432 }
3433 }
3434 return res;
3435 }
3436
3437
3438 SWIGINTERNINLINE PyObject *
3439 SWIG_From_unsigned_SS_char (unsigned char value)
3440 {
3441 return SWIG_From_unsigned_SS_long (value);
3442 }
3443
3444 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3445 wxImageHistogramEntry e = (*self)[key];
3446 return e.value;
3447 }
3448 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3449 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3454 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3455 colour.Green(),
3456 colour.Blue());
3457 wxImageHistogramEntry e = (*self)[key];
3458 return e.value;
3459 }
3460
3461 typedef unsigned char* buffer;
3462
3463
3464 // Pull the nested class out to the top level for SWIG's sake
3465 #define wxImage_RGBValue wxImage::RGBValue
3466 #define wxImage_HSVValue wxImage::HSVValue
3467
3468 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3469 if (width > 0 && height > 0)
3470 return new wxImage(width, height, clear);
3471 else
3472 return new wxImage;
3473 }
3474 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3475 return new wxImage(bitmap.ConvertToImage());
3476 }
3477 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3478 if (DATASIZE != width*height*3) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3480 return NULL;
3481 }
3482
3483 // Copy the source data so the wxImage can clean it up later
3484 buffer copy = (buffer)malloc(DATASIZE);
3485 if (copy == NULL) {
3486 wxPyBLOCK_THREADS(PyErr_NoMemory());
3487 return NULL;
3488 }
3489 memcpy(copy, data, DATASIZE);
3490 return new wxImage(width, height, copy, false);
3491 }
3492 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3493 if (DATASIZE != width*height*3) {
3494 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3495 return NULL;
3496 }
3497 if (ALPHASIZE != width*height) {
3498 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3499 return NULL;
3500 }
3501
3502 // Copy the source data so the wxImage can clean it up later
3503 buffer dcopy = (buffer)malloc(DATASIZE);
3504 if (dcopy == NULL) {
3505 wxPyBLOCK_THREADS(PyErr_NoMemory());
3506 return NULL;
3507 }
3508 memcpy(dcopy, data, DATASIZE);
3509
3510 buffer acopy = (buffer)malloc(ALPHASIZE);
3511 if (acopy == NULL) {
3512 wxPyBLOCK_THREADS(PyErr_NoMemory());
3513 return NULL;
3514 }
3515 memcpy(acopy, alpha, ALPHASIZE);
3516
3517 return new wxImage(width, height, dcopy, acopy, false);
3518 }
3519 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3520 wxSize size(self->GetWidth(), self->GetHeight());
3521 return size;
3522 }
3523 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3524 buffer data = self->GetData();
3525 int len = self->GetWidth() * self->GetHeight() * 3;
3526 PyObject* rv;
3527 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3528 return rv;
3529 }
3530 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3531 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3532 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3533 return;
3534 }
3535 buffer copy = (buffer)malloc(DATASIZE);
3536 if (copy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return;
3539 }
3540 memcpy(copy, data, DATASIZE);
3541 self->SetData(copy, false);
3542 // wxImage takes ownership of copy...
3543 }
3544 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3545 buffer data = self->GetData();
3546 int len = self->GetWidth() * self->GetHeight() * 3;
3547 PyObject* rv;
3548 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3549 return rv;
3550 }
3551 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3552 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3553 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3554 return;
3555 }
3556 self->SetData(data, true);
3557 }
3558 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3559 buffer data = self->GetAlpha();
3560 if (! data) {
3561 RETURN_NONE();
3562 } else {
3563 int len = self->GetWidth() * self->GetHeight();
3564 PyObject* rv;
3565 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3566 return rv;
3567 }
3568 }
3569 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3570 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3571 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3572 return;
3573 }
3574 buffer acopy = (buffer)malloc(ALPHASIZE);
3575 if (acopy == NULL) {
3576 wxPyBLOCK_THREADS(PyErr_NoMemory());
3577 return;
3578 }
3579 memcpy(acopy, alpha, ALPHASIZE);
3580 self->SetAlpha(acopy, false);
3581 // wxImage takes ownership of acopy...
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3588 return rv;
3589 }
3590 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3591 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3592 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3593 return;
3594 }
3595 self->SetAlpha(alpha, true);
3596 }
3597 SWIGINTERN PyObject *wxImage_GetHandlers(){
3598 wxList& list = wxImage::GetHandlers();
3599 return wxPy_ConvertList(&list);
3600 }
3601 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3602 wxBitmap bitmap(*self, depth);
3603 return bitmap;
3604 }
3605 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3606 wxImage mono = self->ConvertToMono( red, green, blue );
3607 wxBitmap bitmap( mono, 1 );
3608 return bitmap;
3609 }
3610 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3611 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3612 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3618 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3619 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3620 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3621 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3622 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3623 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3624 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3625
3626 #include <wx/quantize.h>
3627
3628 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3629 return wxQuantize::Quantize(src, dest,
3630 //NULL, // palette
3631 desiredNoColours,
3632 NULL, // eightBitData
3633 flags);
3634 }
3635 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3636 if (PyCallable_Check(func)) {
3637 self->Connect(id, lastId, eventType,
3638 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3639 new wxPyCallback(func));
3640 }
3641 else if (func == Py_None) {
3642 self->Disconnect(id, lastId, eventType,
3643 (wxObjectEventFunction)
3644 &wxPyCallback::EventThunker);
3645 }
3646 else {
3647 wxPyBLOCK_THREADS(
3648 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3649 }
3650 }
3651 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3652 return self->Disconnect(id, lastId, eventType,
3653 (wxObjectEventFunction)
3654 &wxPyCallback::EventThunker);
3655 }
3656 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3657 if (_self && _self != Py_None) {
3658 self->SetClientObject(new wxPyOORClientData(_self, incref));
3659 }
3660 else {
3661 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3662 if (data) {
3663 self->SetClientObject(NULL); // This will delete it too
3664 }
3665 }
3666 }
3667
3668 #if ! wxUSE_HOTKEY
3669 #define wxEVT_HOTKEY -9999
3670 #endif
3671
3672 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3673 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3674 if (data) {
3675 Py_INCREF(data->m_obj);
3676 return data->m_obj;
3677 } else {
3678 Py_INCREF(Py_None);
3679 return Py_None;
3680 }
3681 }
3682 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3683 wxPyClientData* data = new wxPyClientData(clientData);
3684 self->SetClientObject(data);
3685 }
3686 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3687 #if wxUSE_UNICODE
3688 return self->GetUnicodeKey();
3689 #else
3690 return 0;
3691 #endif
3692 }
3693
3694 SWIGINTERNINLINE PyObject *
3695 SWIG_From_unsigned_SS_int (unsigned int value)
3696 {
3697 return SWIG_From_unsigned_SS_long (value);
3698 }
3699
3700
3701 SWIGINTERN int
3702 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3703 {
3704 unsigned long v;
3705 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3706 if (SWIG_IsOK(res)) {
3707 if ((v > UINT_MAX)) {
3708 return SWIG_OverflowError;
3709 } else {
3710 if (val) *val = static_cast< unsigned int >(v);
3711 }
3712 }
3713 return res;
3714 }
3715
3716 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3717 self->m_size = size;
3718 }
3719 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3720 int count = self->GetNumberOfFiles();
3721 wxString* files = self->GetFiles();
3722 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3723 PyObject* list = PyList_New(count);
3724
3725 if (!list) {
3726 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3727 wxPyEndBlockThreads(blocked);
3728 return NULL;
3729 }
3730
3731 for (int i=0; i<count; i++) {
3732 PyList_SetItem(list, i, wx2PyString(files[i]));
3733 }
3734 wxPyEndBlockThreads(blocked);
3735 return list;
3736 }
3737
3738
3739 SWIGINTERN wxPyApp *new_wxPyApp(){
3740 wxPythonApp = new wxPyApp();
3741 return wxPythonApp;
3742 }
3743 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3744
3745 void wxApp_CleanUp() {
3746 __wxPyCleanup();
3747 }
3748
3749
3750 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3751
3752
3753
3754
3755
3756 SWIGINTERNINLINE PyObject *
3757 SWIG_FromCharPtr(const char *cptr)
3758 {
3759 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3760 }
3761
3762
3763 #if 0 // #ifdef __WXMAC__
3764
3765 // A dummy class that raises an exception if used...
3766 class wxEventLoop
3767 {
3768 public:
3769 wxEventLoop() { wxPyRaiseNotImplemented(); }
3770 int Run() { return 0; }
3771 void Exit(int rc = 0) {}
3772 bool Pending() const { return false; }
3773 bool Dispatch() { return false; }
3774 bool IsRunning() const { return false; }
3775 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3776 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3777 };
3778
3779 #else
3780
3781 #include <wx/evtloop.h>
3782
3783 #endif
3784
3785
3786
3787 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3788 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3789 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3790 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3791 wxWindowList& list = self->GetChildren();
3792 return wxPy_ConvertList(&list);
3793 }
3794 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3795 #if wxUSE_HOTKEY
3796 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3797 #else
3798 return false;
3799 #endif
3800 }
3801 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3802
3803
3804
3805 return false;
3806
3807 }
3808 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3809 return wxPyGetWinHandle(self);
3810 }
3811 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3812 self->AssociateHandle((WXWidget)handle);
3813 }
3814 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3815
3816 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3817 return wxWindow::FindWindowById(id, parent);
3818 }
3819
3820 wxWindow* wxFindWindowByName( const wxString& name,
3821 const wxWindow *parent = NULL ) {
3822 return wxWindow::FindWindowByName(name, parent);
3823 }
3824
3825 wxWindow* wxFindWindowByLabel( const wxString& label,
3826 const wxWindow *parent = NULL ) {
3827 return wxWindow::FindWindowByLabel(label, parent);
3828 }
3829
3830
3831 #ifdef __WXMSW__
3832 #include <wx/msw/private.h> // to get wxGetWindowId
3833 #endif
3834
3835
3836 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3837 #ifdef __WXMSW__
3838 WXHWND hWnd = (WXHWND)_hWnd;
3839 long id = wxGetWindowId(hWnd);
3840 wxWindow* win = new wxWindow;
3841 if (parent)
3842 parent->AddChild(win);
3843 win->SetEventHandler(win);
3844 win->SetHWND(hWnd);
3845 win->SetId(id);
3846 win->SubclassWin(hWnd);
3847 win->AdoptAttributesFromHWND();
3848 win->SetupColours();
3849 return win;
3850 #else
3851 wxPyRaiseNotImplemented();
3852 return NULL;
3853 #endif
3854 }
3855
3856
3857 PyObject* GetTopLevelWindows() {
3858 return wxPy_ConvertList(&wxTopLevelWindows);
3859 }
3860
3861
3862 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3863 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3864 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3865
3866 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3867
3868
3869 SWIGINTERNINLINE int
3870 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3871 {
3872 unsigned long v;
3873 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3874 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3875 return res;
3876 }
3877
3878 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3879 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3880 wxMenuItemList& list = self->GetMenuItems();
3881 return wxPy_ConvertList(&list);
3882 }
3883 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3884 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3885 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3886 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3887 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3888 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3889 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3890 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3891 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3892 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3893 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3894 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3895 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3896 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3897 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3898 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3899 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3900 static const wxString wxPyControlNameStr(wxControlNameStr);
3901 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3902 if (clientData) {
3903 wxPyClientData* data = new wxPyClientData(clientData);
3904 return self->Append(item, data);
3905 } else
3906 return self->Append(item);
3907 }
3908 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3909 if (clientData) {
3910 wxPyClientData* data = new wxPyClientData(clientData);
3911 return self->Insert(item, pos, data);
3912 } else
3913 return self->Insert(item, pos);
3914 }
3915 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3916 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3917 if (data) {
3918 Py_INCREF(data->m_obj);
3919 return data->m_obj;
3920 } else {
3921 Py_INCREF(Py_None);
3922 return Py_None;
3923 }
3924 }
3925 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3926 wxPyClientData* data = new wxPyClientData(clientData);
3927 self->SetClientObject(n, data);
3928 }
3929
3930
3931 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3932 wxPyUserData* data = NULL;
3933 if ( userData ) {
3934 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3935 data = new wxPyUserData(userData);
3936 wxPyEndBlockThreads(blocked);
3937 }
3938 return new wxSizerItem(window, proportion, flag, border, data);
3939 }
3940 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3941 wxPyUserData* data = NULL;
3942 if ( userData ) {
3943 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3944 data = new wxPyUserData(userData);
3945 wxPyEndBlockThreads(blocked);
3946 }
3947 return new wxSizerItem(width, height, proportion, flag, border, data);
3948 }
3949 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3950 wxPyUserData* data = NULL;
3951 if ( userData ) {
3952 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3953 data = new wxPyUserData(userData);
3954 wxPyEndBlockThreads(blocked);
3955 }
3956 return new wxSizerItem(sizer, proportion, flag, border, data);
3957 }
3958
3959 #include <float.h>
3960
3961
3962 SWIGINTERN int
3963 SWIG_AsVal_float (PyObject * obj, float *val)
3964 {
3965 double v;
3966 int res = SWIG_AsVal_double (obj, &v);
3967 if (SWIG_IsOK(res)) {
3968 if ((v < -FLT_MAX || v > FLT_MAX)) {
3969 return SWIG_OverflowError;
3970 } else {
3971 if (val) *val = static_cast< float >(v);
3972 }
3973 }
3974 return res;
3975 }
3976
3977
3978 SWIGINTERNINLINE PyObject *
3979 SWIG_From_float (float value)
3980 {
3981 return SWIG_From_double (value);
3982 }
3983
3984 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3985 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3986 if (data) {
3987 Py_INCREF(data->m_obj);
3988 return data->m_obj;
3989 } else {
3990 Py_INCREF(Py_None);
3991 return Py_None;
3992 }
3993 }
3994 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3995 wxPyUserData* data = NULL;
3996 if ( userData ) {
3997 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3998 data = new wxPyUserData(userData);
3999 wxPyEndBlockThreads(blocked);
4000 }
4001 self->SetUserData(data);
4002 }
4003
4004 // Figure out the type of the sizer item
4005
4006 struct wxPySizerItemInfo {
4007 wxPySizerItemInfo()
4008 : window(NULL), sizer(NULL), gotSize(false),
4009 size(wxDefaultSize), gotPos(false), pos(-1)
4010 {}
4011
4012 wxWindow* window;
4013 wxSizer* sizer;
4014 bool gotSize;
4015 wxSize size;
4016 bool gotPos;
4017 int pos;
4018 };
4019
4020 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4021
4022 wxPySizerItemInfo info;
4023 wxSize size;
4024 wxSize* sizePtr = &size;
4025
4026 // Find out what the type of the item is
4027 // try wxWindow
4028 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4029 PyErr_Clear();
4030 info.window = NULL;
4031
4032 // try wxSizer
4033 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4034 PyErr_Clear();
4035 info.sizer = NULL;
4036
4037 // try wxSize or (w,h)
4038 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4039 info.size = *sizePtr;
4040 info.gotSize = true;
4041 }
4042
4043 // or a single int
4044 if (checkIdx && PyInt_Check(item)) {
4045 info.pos = PyInt_AsLong(item);
4046 info.gotPos = true;
4047 }
4048 }
4049 }
4050
4051 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4052 // no expected type, figure out what kind of error message to generate
4053 if ( !checkSize && !checkIdx )
4054 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4055 else if ( checkSize && !checkIdx )
4056 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4057 else if ( !checkSize && checkIdx)
4058 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4059 else
4060 // can this one happen?
4061 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4062 }
4063
4064 return info;
4065 }
4066
4067 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4068 if (!self->GetClientObject())
4069 self->SetClientObject(new wxPyOORClientData(_self));
4070 }
4071 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4072
4073 wxPyUserData* data = NULL;
4074 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4076 if ( userData && (info.window || info.sizer || info.gotSize) )
4077 data = new wxPyUserData(userData);
4078 if ( info.sizer )
4079 PyObject_SetAttrString(item,"thisown",Py_False);
4080 wxPyEndBlockThreads(blocked);
4081
4082 // Now call the real Add method if a valid item type was found
4083 if ( info.window )
4084 return self->Add(info.window, proportion, flag, border, data);
4085 else if ( info.sizer )
4086 return self->Add(info.sizer, proportion, flag, border, data);
4087 else if (info.gotSize)
4088 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4089 proportion, flag, border, data);
4090 else
4091 return NULL;
4092 }
4093 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4094
4095 wxPyUserData* data = NULL;
4096 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4098 if ( userData && (info.window || info.sizer || info.gotSize) )
4099 data = new wxPyUserData(userData);
4100 if ( info.sizer )
4101 PyObject_SetAttrString(item,"thisown",Py_False);
4102 wxPyEndBlockThreads(blocked);
4103
4104 // Now call the real Insert method if a valid item type was found
4105 if ( info.window )
4106 return self->Insert(before, info.window, proportion, flag, border, data);
4107 else if ( info.sizer )
4108 return self->Insert(before, info.sizer, proportion, flag, border, data);
4109 else if (info.gotSize)
4110 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4111 proportion, flag, border, data);
4112 else
4113 return NULL;
4114 }
4115 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4116
4117 wxPyUserData* data = NULL;
4118 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4119 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4120 if ( userData && (info.window || info.sizer || info.gotSize) )
4121 data = new wxPyUserData(userData);
4122 if ( info.sizer )
4123 PyObject_SetAttrString(item,"thisown",Py_False);
4124 wxPyEndBlockThreads(blocked);
4125
4126 // Now call the real Prepend method if a valid item type was found
4127 if ( info.window )
4128 return self->Prepend(info.window, proportion, flag, border, data);
4129 else if ( info.sizer )
4130 return self->Prepend(info.sizer, proportion, flag, border, data);
4131 else if (info.gotSize)
4132 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4133 proportion, flag, border, data);
4134 else
4135 return NULL;
4136 }
4137 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4138 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4139 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4140 wxPyEndBlockThreads(blocked);
4141 if ( info.window )
4142 return self->Remove(info.window);
4143 else if ( info.sizer )
4144 return self->Remove(info.sizer);
4145 else if ( info.gotPos )
4146 return self->Remove(info.pos);
4147 else
4148 return false;
4149 }
4150 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4151 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4152 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4153 wxPyEndBlockThreads(blocked);
4154 if ( info.window )
4155 return self->Detach(info.window);
4156 else if ( info.sizer )
4157 return self->Detach(info.sizer);
4158 else if ( info.gotPos )
4159 return self->Detach(info.pos);
4160 else
4161 return false;
4162 }
4163 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4164 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4165 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4166 wxPyEndBlockThreads(blocked);
4167 if ( info.window )
4168 return self->GetItem(info.window);
4169 else if ( info.sizer )
4170 return self->GetItem(info.sizer);
4171 else if ( info.gotPos )
4172 return self->GetItem(info.pos);
4173 else
4174 return NULL;
4175 }
4176 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4177 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4178 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4179 wxPyEndBlockThreads(blocked);
4180 if ( info.window )
4181 self->SetItemMinSize(info.window, size);
4182 else if ( info.sizer )
4183 self->SetItemMinSize(info.sizer, size);
4184 else if ( info.gotPos )
4185 self->SetItemMinSize(info.pos, size);
4186 }
4187 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4188 wxSizerItemList& list = self->GetChildren();
4189 return wxPy_ConvertList(&list);
4190 }
4191 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4194 wxPyEndBlockThreads(blocked);
4195 if ( info.window )
4196 return self->Show(info.window, show, recursive);
4197 else if ( info.sizer )
4198 return self->Show(info.sizer, show, recursive);
4199 else if ( info.gotPos )
4200 return self->Show(info.pos, show);
4201 else
4202 return false;
4203 }
4204 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4205 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4206 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4207 wxPyEndBlockThreads(blocked);
4208 if ( info.window )
4209 return self->IsShown(info.window);
4210 else if ( info.sizer )
4211 return self->IsShown(info.sizer);
4212 else if ( info.gotPos )
4213 return self->IsShown(info.pos);
4214 else
4215 return false;
4216 }
4217
4218 // See pyclasses.h
4219 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4220 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4221 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4222
4223
4224
4225
4226 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4227 {
4228 if (source == Py_None) {
4229 **obj = wxGBPosition(-1,-1);
4230 return true;
4231 }
4232 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4233 }
4234
4235 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4236 {
4237 if (source == Py_None) {
4238 **obj = wxGBSpan(-1,-1);
4239 return true;
4240 }
4241 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4242 }
4243
4244
4245 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4246 wxGBPosition temp, *obj = &temp;
4247 if ( other == Py_None ) return false;
4248 if ( ! wxGBPosition_helper(other, &obj) ) {
4249 PyErr_Clear();
4250 return false;
4251 }
4252 return self->operator==(*obj);
4253 }
4254 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4255 wxGBPosition temp, *obj = &temp;
4256 if ( other == Py_None ) return true;
4257 if ( ! wxGBPosition_helper(other, &obj)) {
4258 PyErr_Clear();
4259 return true;
4260 }
4261 return self->operator!=(*obj);
4262 }
4263 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4264 self->SetRow(row);
4265 self->SetCol(col);
4266 }
4267 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4268 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4269 PyObject* tup = PyTuple_New(2);
4270 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4271 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4272 wxPyEndBlockThreads(blocked);
4273 return tup;
4274 }
4275 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4276 wxGBSpan temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBSpan_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4285 wxGBSpan temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBSpan_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4294 self->SetRowspan(rowspan);
4295 self->SetColspan(colspan);
4296 }
4297 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4306 wxPyUserData* data = NULL;
4307 if ( userData ) {
4308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4309 data = new wxPyUserData(userData);
4310 wxPyEndBlockThreads(blocked);
4311 }
4312 return new wxGBSizerItem(window, pos, span, flag, border, data);
4313 }
4314 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4315 wxPyUserData* data = NULL;
4316 if ( userData ) {
4317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4318 data = new wxPyUserData(userData);
4319 wxPyEndBlockThreads(blocked);
4320 }
4321 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4322 }
4323 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4324 wxPyUserData* data = NULL;
4325 if ( userData ) {
4326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4327 data = new wxPyUserData(userData);
4328 wxPyEndBlockThreads(blocked);
4329 }
4330 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4331 }
4332 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4333 int row, col;
4334 self->GetEndPos(row, col);
4335 return wxGBPosition(row, col);
4336 }
4337 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4338
4339 wxPyUserData* data = NULL;
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4342 if ( userData && (info.window || info.sizer || info.gotSize) )
4343 data = new wxPyUserData(userData);
4344 if ( info.sizer )
4345 PyObject_SetAttrString(item,"thisown",Py_False);
4346 wxPyEndBlockThreads(blocked);
4347
4348 // Now call the real Add method if a valid item type was found
4349 if ( info.window )
4350 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4351 else if ( info.sizer )
4352 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4353 else if (info.gotSize)
4354 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4355 pos, span, flag, border, data);
4356 return NULL;
4357 }
4358
4359
4360 #ifdef __cplusplus
4361 extern "C" {
4362 #endif
4363 SWIGINTERN int EmptyString_set(PyObject *) {
4364 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4365 return 1;
4366 }
4367
4368
4369 SWIGINTERN PyObject *EmptyString_get(void) {
4370 PyObject *pyobj = 0;
4371
4372 {
4373 #if wxUSE_UNICODE
4374 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4375 #else
4376 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4377 #endif
4378 }
4379 return pyobj;
4380 }
4381
4382
4383 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4384 PyObject *resultobj = 0;
4385 wxObject *arg1 = (wxObject *) 0 ;
4386 wxString result;
4387 void *argp1 = 0 ;
4388 int res1 = 0 ;
4389 PyObject *swig_obj[1] ;
4390
4391 if (!args) SWIG_fail;
4392 swig_obj[0] = args;
4393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4394 if (!SWIG_IsOK(res1)) {
4395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4396 }
4397 arg1 = reinterpret_cast< wxObject * >(argp1);
4398 {
4399 PyThreadState* __tstate = wxPyBeginAllowThreads();
4400 result = wxObject_GetClassName(arg1);
4401 wxPyEndAllowThreads(__tstate);
4402 if (PyErr_Occurred()) SWIG_fail;
4403 }
4404 {
4405 #if wxUSE_UNICODE
4406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4407 #else
4408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4409 #endif
4410 }
4411 return resultobj;
4412 fail:
4413 return NULL;
4414 }
4415
4416
4417 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4418 PyObject *resultobj = 0;
4419 wxObject *arg1 = (wxObject *) 0 ;
4420 void *argp1 = 0 ;
4421 int res1 = 0 ;
4422 PyObject *swig_obj[1] ;
4423
4424 if (!args) SWIG_fail;
4425 swig_obj[0] = args;
4426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4427 if (!SWIG_IsOK(res1)) {
4428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4429 }
4430 arg1 = reinterpret_cast< wxObject * >(argp1);
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 wxObject_Destroy(arg1);
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 resultobj = SWIG_Py_Void();
4438 return resultobj;
4439 fail:
4440 return NULL;
4441 }
4442
4443
4444 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4445 PyObject *obj;
4446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4447 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4448 return SWIG_Py_Void();
4449 }
4450
4451 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4452 PyObject *resultobj = 0;
4453 wxSize *arg1 = (wxSize *) 0 ;
4454 int arg2 ;
4455 void *argp1 = 0 ;
4456 int res1 = 0 ;
4457 int val2 ;
4458 int ecode2 = 0 ;
4459 PyObject *swig_obj[2] ;
4460
4461 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4463 if (!SWIG_IsOK(res1)) {
4464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4465 }
4466 arg1 = reinterpret_cast< wxSize * >(argp1);
4467 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4468 if (!SWIG_IsOK(ecode2)) {
4469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4470 }
4471 arg2 = static_cast< int >(val2);
4472 if (arg1) (arg1)->x = arg2;
4473
4474 resultobj = SWIG_Py_Void();
4475 return resultobj;
4476 fail:
4477 return NULL;
4478 }
4479
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int result;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 PyObject *swig_obj[1] ;
4488
4489 if (!args) SWIG_fail;
4490 swig_obj[0] = args;
4491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4492 if (!SWIG_IsOK(res1)) {
4493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4494 }
4495 arg1 = reinterpret_cast< wxSize * >(argp1);
4496 result = (int) ((arg1)->x);
4497 resultobj = SWIG_From_int(static_cast< int >(result));
4498 return resultobj;
4499 fail:
4500 return NULL;
4501 }
4502
4503
4504 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4505 PyObject *resultobj = 0;
4506 wxSize *arg1 = (wxSize *) 0 ;
4507 int arg2 ;
4508 void *argp1 = 0 ;
4509 int res1 = 0 ;
4510 int val2 ;
4511 int ecode2 = 0 ;
4512 PyObject *swig_obj[2] ;
4513
4514 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4516 if (!SWIG_IsOK(res1)) {
4517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4518 }
4519 arg1 = reinterpret_cast< wxSize * >(argp1);
4520 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4521 if (!SWIG_IsOK(ecode2)) {
4522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4523 }
4524 arg2 = static_cast< int >(val2);
4525 if (arg1) (arg1)->y = arg2;
4526
4527 resultobj = SWIG_Py_Void();
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int result;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 PyObject *swig_obj[1] ;
4541
4542 if (!args) SWIG_fail;
4543 swig_obj[0] = args;
4544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4545 if (!SWIG_IsOK(res1)) {
4546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4547 }
4548 arg1 = reinterpret_cast< wxSize * >(argp1);
4549 result = (int) ((arg1)->y);
4550 resultobj = SWIG_From_int(static_cast< int >(result));
4551 return resultobj;
4552 fail:
4553 return NULL;
4554 }
4555
4556
4557 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4558 PyObject *resultobj = 0;
4559 int arg1 = (int) 0 ;
4560 int arg2 = (int) 0 ;
4561 wxSize *result = 0 ;
4562 int val1 ;
4563 int ecode1 = 0 ;
4564 int val2 ;
4565 int ecode2 = 0 ;
4566 PyObject * obj0 = 0 ;
4567 PyObject * obj1 = 0 ;
4568 char * kwnames[] = {
4569 (char *) "w",(char *) "h", NULL
4570 };
4571
4572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4573 if (obj0) {
4574 ecode1 = SWIG_AsVal_int(obj0, &val1);
4575 if (!SWIG_IsOK(ecode1)) {
4576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4577 }
4578 arg1 = static_cast< int >(val1);
4579 }
4580 if (obj1) {
4581 ecode2 = SWIG_AsVal_int(obj1, &val2);
4582 if (!SWIG_IsOK(ecode2)) {
4583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4584 }
4585 arg2 = static_cast< int >(val2);
4586 }
4587 {
4588 PyThreadState* __tstate = wxPyBeginAllowThreads();
4589 result = (wxSize *)new wxSize(arg1,arg2);
4590 wxPyEndAllowThreads(__tstate);
4591 if (PyErr_Occurred()) SWIG_fail;
4592 }
4593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4594 return resultobj;
4595 fail:
4596 return NULL;
4597 }
4598
4599
4600 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4601 PyObject *resultobj = 0;
4602 wxSize *arg1 = (wxSize *) 0 ;
4603 void *argp1 = 0 ;
4604 int res1 = 0 ;
4605 PyObject *swig_obj[1] ;
4606
4607 if (!args) SWIG_fail;
4608 swig_obj[0] = args;
4609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4610 if (!SWIG_IsOK(res1)) {
4611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4612 }
4613 arg1 = reinterpret_cast< wxSize * >(argp1);
4614 {
4615 PyThreadState* __tstate = wxPyBeginAllowThreads();
4616 delete arg1;
4617
4618 wxPyEndAllowThreads(__tstate);
4619 if (PyErr_Occurred()) SWIG_fail;
4620 }
4621 resultobj = SWIG_Py_Void();
4622 return resultobj;
4623 fail:
4624 return NULL;
4625 }
4626
4627
4628 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4629 PyObject *resultobj = 0;
4630 wxSize *arg1 = (wxSize *) 0 ;
4631 PyObject *arg2 = (PyObject *) 0 ;
4632 bool result;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject * obj0 = 0 ;
4636 PyObject * obj1 = 0 ;
4637 char * kwnames[] = {
4638 (char *) "self",(char *) "other", NULL
4639 };
4640
4641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4643 if (!SWIG_IsOK(res1)) {
4644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4645 }
4646 arg1 = reinterpret_cast< wxSize * >(argp1);
4647 arg2 = obj1;
4648 {
4649 result = (bool)wxSize___eq__(arg1,arg2);
4650 if (PyErr_Occurred()) SWIG_fail;
4651 }
4652 {
4653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4654 }
4655 return resultobj;
4656 fail:
4657 return NULL;
4658 }
4659
4660
4661 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj = 0;
4663 wxSize *arg1 = (wxSize *) 0 ;
4664 PyObject *arg2 = (PyObject *) 0 ;
4665 bool result;
4666 void *argp1 = 0 ;
4667 int res1 = 0 ;
4668 PyObject * obj0 = 0 ;
4669 PyObject * obj1 = 0 ;
4670 char * kwnames[] = {
4671 (char *) "self",(char *) "other", NULL
4672 };
4673
4674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4676 if (!SWIG_IsOK(res1)) {
4677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4678 }
4679 arg1 = reinterpret_cast< wxSize * >(argp1);
4680 arg2 = obj1;
4681 {
4682 result = (bool)wxSize___ne__(arg1,arg2);
4683 if (PyErr_Occurred()) SWIG_fail;
4684 }
4685 {
4686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4687 }
4688 return resultobj;
4689 fail:
4690 return NULL;
4691 }
4692
4693
4694 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4695 PyObject *resultobj = 0;
4696 wxSize *arg1 = (wxSize *) 0 ;
4697 wxSize *arg2 = 0 ;
4698 wxSize result;
4699 void *argp1 = 0 ;
4700 int res1 = 0 ;
4701 wxSize temp2 ;
4702 PyObject * obj0 = 0 ;
4703 PyObject * obj1 = 0 ;
4704 char * kwnames[] = {
4705 (char *) "self",(char *) "sz", NULL
4706 };
4707
4708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4710 if (!SWIG_IsOK(res1)) {
4711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4712 }
4713 arg1 = reinterpret_cast< wxSize * >(argp1);
4714 {
4715 arg2 = &temp2;
4716 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4717 }
4718 {
4719 PyThreadState* __tstate = wxPyBeginAllowThreads();
4720 result = (arg1)->operator +((wxSize const &)*arg2);
4721 wxPyEndAllowThreads(__tstate);
4722 if (PyErr_Occurred()) SWIG_fail;
4723 }
4724 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4725 return resultobj;
4726 fail:
4727 return NULL;
4728 }
4729
4730
4731 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4732 PyObject *resultobj = 0;
4733 wxSize *arg1 = (wxSize *) 0 ;
4734 wxSize *arg2 = 0 ;
4735 wxSize result;
4736 void *argp1 = 0 ;
4737 int res1 = 0 ;
4738 wxSize temp2 ;
4739 PyObject * obj0 = 0 ;
4740 PyObject * obj1 = 0 ;
4741 char * kwnames[] = {
4742 (char *) "self",(char *) "sz", NULL
4743 };
4744
4745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4747 if (!SWIG_IsOK(res1)) {
4748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4749 }
4750 arg1 = reinterpret_cast< wxSize * >(argp1);
4751 {
4752 arg2 = &temp2;
4753 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4754 }
4755 {
4756 PyThreadState* __tstate = wxPyBeginAllowThreads();
4757 result = (arg1)->operator -((wxSize const &)*arg2);
4758 wxPyEndAllowThreads(__tstate);
4759 if (PyErr_Occurred()) SWIG_fail;
4760 }
4761 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4762 return resultobj;
4763 fail:
4764 return NULL;
4765 }
4766
4767
4768 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4769 PyObject *resultobj = 0;
4770 wxSize *arg1 = (wxSize *) 0 ;
4771 wxSize *arg2 = 0 ;
4772 void *argp1 = 0 ;
4773 int res1 = 0 ;
4774 wxSize temp2 ;
4775 PyObject * obj0 = 0 ;
4776 PyObject * obj1 = 0 ;
4777 char * kwnames[] = {
4778 (char *) "self",(char *) "sz", NULL
4779 };
4780
4781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4783 if (!SWIG_IsOK(res1)) {
4784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4785 }
4786 arg1 = reinterpret_cast< wxSize * >(argp1);
4787 {
4788 arg2 = &temp2;
4789 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4790 }
4791 {
4792 PyThreadState* __tstate = wxPyBeginAllowThreads();
4793 (arg1)->IncTo((wxSize const &)*arg2);
4794 wxPyEndAllowThreads(__tstate);
4795 if (PyErr_Occurred()) SWIG_fail;
4796 }
4797 resultobj = SWIG_Py_Void();
4798 return resultobj;
4799 fail:
4800 return NULL;
4801 }
4802
4803
4804 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4805 PyObject *resultobj = 0;
4806 wxSize *arg1 = (wxSize *) 0 ;
4807 wxSize *arg2 = 0 ;
4808 void *argp1 = 0 ;
4809 int res1 = 0 ;
4810 wxSize temp2 ;
4811 PyObject * obj0 = 0 ;
4812 PyObject * obj1 = 0 ;
4813 char * kwnames[] = {
4814 (char *) "self",(char *) "sz", NULL
4815 };
4816
4817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4819 if (!SWIG_IsOK(res1)) {
4820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4821 }
4822 arg1 = reinterpret_cast< wxSize * >(argp1);
4823 {
4824 arg2 = &temp2;
4825 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4826 }
4827 {
4828 PyThreadState* __tstate = wxPyBeginAllowThreads();
4829 (arg1)->DecTo((wxSize const &)*arg2);
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 resultobj = SWIG_Py_Void();
4834 return resultobj;
4835 fail:
4836 return NULL;
4837 }
4838
4839
4840 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4841 PyObject *resultobj = 0;
4842 wxSize *arg1 = (wxSize *) 0 ;
4843 int arg2 ;
4844 int arg3 ;
4845 void *argp1 = 0 ;
4846 int res1 = 0 ;
4847 int val2 ;
4848 int ecode2 = 0 ;
4849 int val3 ;
4850 int ecode3 = 0 ;
4851 PyObject * obj0 = 0 ;
4852 PyObject * obj1 = 0 ;
4853 PyObject * obj2 = 0 ;
4854 char * kwnames[] = {
4855 (char *) "self",(char *) "w",(char *) "h", NULL
4856 };
4857
4858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4860 if (!SWIG_IsOK(res1)) {
4861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4862 }
4863 arg1 = reinterpret_cast< wxSize * >(argp1);
4864 ecode2 = SWIG_AsVal_int(obj1, &val2);
4865 if (!SWIG_IsOK(ecode2)) {
4866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4867 }
4868 arg2 = static_cast< int >(val2);
4869 ecode3 = SWIG_AsVal_int(obj2, &val3);
4870 if (!SWIG_IsOK(ecode3)) {
4871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4872 }
4873 arg3 = static_cast< int >(val3);
4874 {
4875 PyThreadState* __tstate = wxPyBeginAllowThreads();
4876 (arg1)->Set(arg2,arg3);
4877 wxPyEndAllowThreads(__tstate);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 resultobj = SWIG_Py_Void();
4881 return resultobj;
4882 fail:
4883 return NULL;
4884 }
4885
4886
4887 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4888 PyObject *resultobj = 0;
4889 wxSize *arg1 = (wxSize *) 0 ;
4890 int arg2 ;
4891 void *argp1 = 0 ;
4892 int res1 = 0 ;
4893 int val2 ;
4894 int ecode2 = 0 ;
4895 PyObject * obj0 = 0 ;
4896 PyObject * obj1 = 0 ;
4897 char * kwnames[] = {
4898 (char *) "self",(char *) "w", NULL
4899 };
4900
4901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4903 if (!SWIG_IsOK(res1)) {
4904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4905 }
4906 arg1 = reinterpret_cast< wxSize * >(argp1);
4907 ecode2 = SWIG_AsVal_int(obj1, &val2);
4908 if (!SWIG_IsOK(ecode2)) {
4909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4910 }
4911 arg2 = static_cast< int >(val2);
4912 {
4913 PyThreadState* __tstate = wxPyBeginAllowThreads();
4914 (arg1)->SetWidth(arg2);
4915 wxPyEndAllowThreads(__tstate);
4916 if (PyErr_Occurred()) SWIG_fail;
4917 }
4918 resultobj = SWIG_Py_Void();
4919 return resultobj;
4920 fail:
4921 return NULL;
4922 }
4923
4924
4925 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4926 PyObject *resultobj = 0;
4927 wxSize *arg1 = (wxSize *) 0 ;
4928 int arg2 ;
4929 void *argp1 = 0 ;
4930 int res1 = 0 ;
4931 int val2 ;
4932 int ecode2 = 0 ;
4933 PyObject * obj0 = 0 ;
4934 PyObject * obj1 = 0 ;
4935 char * kwnames[] = {
4936 (char *) "self",(char *) "h", NULL
4937 };
4938
4939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4941 if (!SWIG_IsOK(res1)) {
4942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4943 }
4944 arg1 = reinterpret_cast< wxSize * >(argp1);
4945 ecode2 = SWIG_AsVal_int(obj1, &val2);
4946 if (!SWIG_IsOK(ecode2)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4948 }
4949 arg2 = static_cast< int >(val2);
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 (arg1)->SetHeight(arg2);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_Py_Void();
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4964 PyObject *resultobj = 0;
4965 wxSize *arg1 = (wxSize *) 0 ;
4966 int result;
4967 void *argp1 = 0 ;
4968 int res1 = 0 ;
4969 PyObject *swig_obj[1] ;
4970
4971 if (!args) SWIG_fail;
4972 swig_obj[0] = args;
4973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4974 if (!SWIG_IsOK(res1)) {
4975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4976 }
4977 arg1 = reinterpret_cast< wxSize * >(argp1);
4978 {
4979 PyThreadState* __tstate = wxPyBeginAllowThreads();
4980 result = (int)((wxSize const *)arg1)->GetWidth();
4981 wxPyEndAllowThreads(__tstate);
4982 if (PyErr_Occurred()) SWIG_fail;
4983 }
4984 resultobj = SWIG_From_int(static_cast< int >(result));
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4992 PyObject *resultobj = 0;
4993 wxSize *arg1 = (wxSize *) 0 ;
4994 int result;
4995 void *argp1 = 0 ;
4996 int res1 = 0 ;
4997 PyObject *swig_obj[1] ;
4998
4999 if (!args) SWIG_fail;
5000 swig_obj[0] = args;
5001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5002 if (!SWIG_IsOK(res1)) {
5003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5004 }
5005 arg1 = reinterpret_cast< wxSize * >(argp1);
5006 {
5007 PyThreadState* __tstate = wxPyBeginAllowThreads();
5008 result = (int)((wxSize const *)arg1)->GetHeight();
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 resultobj = SWIG_From_int(static_cast< int >(result));
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5020 PyObject *resultobj = 0;
5021 wxSize *arg1 = (wxSize *) 0 ;
5022 bool result;
5023 void *argp1 = 0 ;
5024 int res1 = 0 ;
5025 PyObject *swig_obj[1] ;
5026
5027 if (!args) SWIG_fail;
5028 swig_obj[0] = args;
5029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5030 if (!SWIG_IsOK(res1)) {
5031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5032 }
5033 arg1 = reinterpret_cast< wxSize * >(argp1);
5034 {
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 {
5041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5042 }
5043 return resultobj;
5044 fail:
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5050 PyObject *resultobj = 0;
5051 wxSize *arg1 = (wxSize *) 0 ;
5052 wxSize *arg2 = 0 ;
5053 void *argp1 = 0 ;
5054 int res1 = 0 ;
5055 wxSize temp2 ;
5056 PyObject * obj0 = 0 ;
5057 PyObject * obj1 = 0 ;
5058 char * kwnames[] = {
5059 (char *) "self",(char *) "size", NULL
5060 };
5061
5062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5064 if (!SWIG_IsOK(res1)) {
5065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5066 }
5067 arg1 = reinterpret_cast< wxSize * >(argp1);
5068 {
5069 arg2 = &temp2;
5070 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5071 }
5072 {
5073 PyThreadState* __tstate = wxPyBeginAllowThreads();
5074 (arg1)->SetDefaults((wxSize const &)*arg2);
5075 wxPyEndAllowThreads(__tstate);
5076 if (PyErr_Occurred()) SWIG_fail;
5077 }
5078 resultobj = SWIG_Py_Void();
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
5085 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5086 PyObject *resultobj = 0;
5087 wxSize *arg1 = (wxSize *) 0 ;
5088 PyObject *result = 0 ;
5089 void *argp1 = 0 ;
5090 int res1 = 0 ;
5091 PyObject *swig_obj[1] ;
5092
5093 if (!args) SWIG_fail;
5094 swig_obj[0] = args;
5095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5096 if (!SWIG_IsOK(res1)) {
5097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5098 }
5099 arg1 = reinterpret_cast< wxSize * >(argp1);
5100 {
5101 PyThreadState* __tstate = wxPyBeginAllowThreads();
5102 result = (PyObject *)wxSize_Get(arg1);
5103 wxPyEndAllowThreads(__tstate);
5104 if (PyErr_Occurred()) SWIG_fail;
5105 }
5106 resultobj = result;
5107 return resultobj;
5108 fail:
5109 return NULL;
5110 }
5111
5112
5113 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5114 PyObject *obj;
5115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5116 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5117 return SWIG_Py_Void();
5118 }
5119
5120 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 return SWIG_Python_InitShadowInstance(args);
5122 }
5123
5124 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5125 PyObject *resultobj = 0;
5126 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5127 double arg2 ;
5128 void *argp1 = 0 ;
5129 int res1 = 0 ;
5130 double val2 ;
5131 int ecode2 = 0 ;
5132 PyObject *swig_obj[2] ;
5133
5134 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5136 if (!SWIG_IsOK(res1)) {
5137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5138 }
5139 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5140 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5141 if (!SWIG_IsOK(ecode2)) {
5142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5143 }
5144 arg2 = static_cast< double >(val2);
5145 if (arg1) (arg1)->x = arg2;
5146
5147 resultobj = SWIG_Py_Void();
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
5154 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5155 PyObject *resultobj = 0;
5156 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5157 double result;
5158 void *argp1 = 0 ;
5159 int res1 = 0 ;
5160 PyObject *swig_obj[1] ;
5161
5162 if (!args) SWIG_fail;
5163 swig_obj[0] = args;
5164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5165 if (!SWIG_IsOK(res1)) {
5166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5167 }
5168 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5169 result = (double) ((arg1)->x);
5170 resultobj = SWIG_From_double(static_cast< double >(result));
5171 return resultobj;
5172 fail:
5173 return NULL;
5174 }
5175
5176
5177 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5178 PyObject *resultobj = 0;
5179 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5180 double arg2 ;
5181 void *argp1 = 0 ;
5182 int res1 = 0 ;
5183 double val2 ;
5184 int ecode2 = 0 ;
5185 PyObject *swig_obj[2] ;
5186
5187 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5189 if (!SWIG_IsOK(res1)) {
5190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5191 }
5192 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5193 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5194 if (!SWIG_IsOK(ecode2)) {
5195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5196 }
5197 arg2 = static_cast< double >(val2);
5198 if (arg1) (arg1)->y = arg2;
5199
5200 resultobj = SWIG_Py_Void();
5201 return resultobj;
5202 fail:
5203 return NULL;
5204 }
5205
5206
5207 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5208 PyObject *resultobj = 0;
5209 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5210 double result;
5211 void *argp1 = 0 ;
5212 int res1 = 0 ;
5213 PyObject *swig_obj[1] ;
5214
5215 if (!args) SWIG_fail;
5216 swig_obj[0] = args;
5217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5218 if (!SWIG_IsOK(res1)) {
5219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5220 }
5221 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5222 result = (double) ((arg1)->y);
5223 resultobj = SWIG_From_double(static_cast< double >(result));
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5231 PyObject *resultobj = 0;
5232 double arg1 = (double) 0.0 ;
5233 double arg2 = (double) 0.0 ;
5234 wxRealPoint *result = 0 ;
5235 double val1 ;
5236 int ecode1 = 0 ;
5237 double val2 ;
5238 int ecode2 = 0 ;
5239 PyObject * obj0 = 0 ;
5240 PyObject * obj1 = 0 ;
5241 char * kwnames[] = {
5242 (char *) "x",(char *) "y", NULL
5243 };
5244
5245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5246 if (obj0) {
5247 ecode1 = SWIG_AsVal_double(obj0, &val1);
5248 if (!SWIG_IsOK(ecode1)) {
5249 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5250 }
5251 arg1 = static_cast< double >(val1);
5252 }
5253 if (obj1) {
5254 ecode2 = SWIG_AsVal_double(obj1, &val2);
5255 if (!SWIG_IsOK(ecode2)) {
5256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5257 }
5258 arg2 = static_cast< double >(val2);
5259 }
5260 {
5261 PyThreadState* __tstate = wxPyBeginAllowThreads();
5262 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5263 wxPyEndAllowThreads(__tstate);
5264 if (PyErr_Occurred()) SWIG_fail;
5265 }
5266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5267 return resultobj;
5268 fail:
5269 return NULL;
5270 }
5271
5272
5273 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5274 PyObject *resultobj = 0;
5275 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5276 void *argp1 = 0 ;
5277 int res1 = 0 ;
5278 PyObject *swig_obj[1] ;
5279
5280 if (!args) SWIG_fail;
5281 swig_obj[0] = args;
5282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5283 if (!SWIG_IsOK(res1)) {
5284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5285 }
5286 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 delete arg1;
5290
5291 wxPyEndAllowThreads(__tstate);
5292 if (PyErr_Occurred()) SWIG_fail;
5293 }
5294 resultobj = SWIG_Py_Void();
5295 return resultobj;
5296 fail:
5297 return NULL;
5298 }
5299
5300
5301 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5302 PyObject *resultobj = 0;
5303 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5304 PyObject *arg2 = (PyObject *) 0 ;
5305 bool result;
5306 void *argp1 = 0 ;
5307 int res1 = 0 ;
5308 PyObject * obj0 = 0 ;
5309 PyObject * obj1 = 0 ;
5310 char * kwnames[] = {
5311 (char *) "self",(char *) "other", NULL
5312 };
5313
5314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5316 if (!SWIG_IsOK(res1)) {
5317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5318 }
5319 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5320 arg2 = obj1;
5321 {
5322 result = (bool)wxRealPoint___eq__(arg1,arg2);
5323 if (PyErr_Occurred()) SWIG_fail;
5324 }
5325 {
5326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5327 }
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 PyObject *arg2 = (PyObject *) 0 ;
5338 bool result;
5339 void *argp1 = 0 ;
5340 int res1 = 0 ;
5341 PyObject * obj0 = 0 ;
5342 PyObject * obj1 = 0 ;
5343 char * kwnames[] = {
5344 (char *) "self",(char *) "other", NULL
5345 };
5346
5347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5349 if (!SWIG_IsOK(res1)) {
5350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5351 }
5352 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5353 arg2 = obj1;
5354 {
5355 result = (bool)wxRealPoint___ne__(arg1,arg2);
5356 if (PyErr_Occurred()) SWIG_fail;
5357 }
5358 {
5359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5360 }
5361 return resultobj;
5362 fail:
5363 return NULL;
5364 }
5365
5366
5367 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5368 PyObject *resultobj = 0;
5369 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5370 wxRealPoint *arg2 = 0 ;
5371 wxRealPoint result;
5372 void *argp1 = 0 ;
5373 int res1 = 0 ;
5374 wxRealPoint temp2 ;
5375 PyObject * obj0 = 0 ;
5376 PyObject * obj1 = 0 ;
5377 char * kwnames[] = {
5378 (char *) "self",(char *) "pt", NULL
5379 };
5380
5381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5383 if (!SWIG_IsOK(res1)) {
5384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5385 }
5386 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5387 {
5388 arg2 = &temp2;
5389 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5390 }
5391 {
5392 PyThreadState* __tstate = wxPyBeginAllowThreads();
5393 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5394 wxPyEndAllowThreads(__tstate);
5395 if (PyErr_Occurred()) SWIG_fail;
5396 }
5397 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj = 0;
5406 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5407 wxRealPoint *arg2 = 0 ;
5408 wxRealPoint result;
5409 void *argp1 = 0 ;
5410 int res1 = 0 ;
5411 wxRealPoint temp2 ;
5412 PyObject * obj0 = 0 ;
5413 PyObject * obj1 = 0 ;
5414 char * kwnames[] = {
5415 (char *) "self",(char *) "pt", NULL
5416 };
5417
5418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5420 if (!SWIG_IsOK(res1)) {
5421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5422 }
5423 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5424 {
5425 arg2 = &temp2;
5426 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5427 }
5428 {
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5431 wxPyEndAllowThreads(__tstate);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5435 return resultobj;
5436 fail:
5437 return NULL;
5438 }
5439
5440
5441 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5442 PyObject *resultobj = 0;
5443 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5444 double arg2 ;
5445 double arg3 ;
5446 void *argp1 = 0 ;
5447 int res1 = 0 ;
5448 double val2 ;
5449 int ecode2 = 0 ;
5450 double val3 ;
5451 int ecode3 = 0 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 PyObject * obj2 = 0 ;
5455 char * kwnames[] = {
5456 (char *) "self",(char *) "x",(char *) "y", NULL
5457 };
5458
5459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5461 if (!SWIG_IsOK(res1)) {
5462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5463 }
5464 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5465 ecode2 = SWIG_AsVal_double(obj1, &val2);
5466 if (!SWIG_IsOK(ecode2)) {
5467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5468 }
5469 arg2 = static_cast< double >(val2);
5470 ecode3 = SWIG_AsVal_double(obj2, &val3);
5471 if (!SWIG_IsOK(ecode3)) {
5472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5473 }
5474 arg3 = static_cast< double >(val3);
5475 {
5476 PyThreadState* __tstate = wxPyBeginAllowThreads();
5477 wxRealPoint_Set(arg1,arg2,arg3);
5478 wxPyEndAllowThreads(__tstate);
5479 if (PyErr_Occurred()) SWIG_fail;
5480 }
5481 resultobj = SWIG_Py_Void();
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5489 PyObject *resultobj = 0;
5490 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5491 PyObject *result = 0 ;
5492 void *argp1 = 0 ;
5493 int res1 = 0 ;
5494 PyObject *swig_obj[1] ;
5495
5496 if (!args) SWIG_fail;
5497 swig_obj[0] = args;
5498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5499 if (!SWIG_IsOK(res1)) {
5500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5501 }
5502 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5503 {
5504 PyThreadState* __tstate = wxPyBeginAllowThreads();
5505 result = (PyObject *)wxRealPoint_Get(arg1);
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 resultobj = result;
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5517 PyObject *obj;
5518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5519 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5520 return SWIG_Py_Void();
5521 }
5522
5523 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5524 return SWIG_Python_InitShadowInstance(args);
5525 }
5526
5527 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5528 PyObject *resultobj = 0;
5529 wxPoint *arg1 = (wxPoint *) 0 ;
5530 int arg2 ;
5531 void *argp1 = 0 ;
5532 int res1 = 0 ;
5533 int val2 ;
5534 int ecode2 = 0 ;
5535 PyObject *swig_obj[2] ;
5536
5537 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5539 if (!SWIG_IsOK(res1)) {
5540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5541 }
5542 arg1 = reinterpret_cast< wxPoint * >(argp1);
5543 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5544 if (!SWIG_IsOK(ecode2)) {
5545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5546 }
5547 arg2 = static_cast< int >(val2);
5548 if (arg1) (arg1)->x = arg2;
5549
5550 resultobj = SWIG_Py_Void();
5551 return resultobj;
5552 fail:
5553 return NULL;
5554 }
5555
5556
5557 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5558 PyObject *resultobj = 0;
5559 wxPoint *arg1 = (wxPoint *) 0 ;
5560 int result;
5561 void *argp1 = 0 ;
5562 int res1 = 0 ;
5563 PyObject *swig_obj[1] ;
5564
5565 if (!args) SWIG_fail;
5566 swig_obj[0] = args;
5567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5568 if (!SWIG_IsOK(res1)) {
5569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5570 }
5571 arg1 = reinterpret_cast< wxPoint * >(argp1);
5572 result = (int) ((arg1)->x);
5573 resultobj = SWIG_From_int(static_cast< int >(result));
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5581 PyObject *resultobj = 0;
5582 wxPoint *arg1 = (wxPoint *) 0 ;
5583 int arg2 ;
5584 void *argp1 = 0 ;
5585 int res1 = 0 ;
5586 int val2 ;
5587 int ecode2 = 0 ;
5588 PyObject *swig_obj[2] ;
5589
5590 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5592 if (!SWIG_IsOK(res1)) {
5593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5594 }
5595 arg1 = reinterpret_cast< wxPoint * >(argp1);
5596 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5597 if (!SWIG_IsOK(ecode2)) {
5598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5599 }
5600 arg2 = static_cast< int >(val2);
5601 if (arg1) (arg1)->y = arg2;
5602
5603 resultobj = SWIG_Py_Void();
5604 return resultobj;
5605 fail:
5606 return NULL;
5607 }
5608
5609
5610 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5611 PyObject *resultobj = 0;
5612 wxPoint *arg1 = (wxPoint *) 0 ;
5613 int result;
5614 void *argp1 = 0 ;
5615 int res1 = 0 ;
5616 PyObject *swig_obj[1] ;
5617
5618 if (!args) SWIG_fail;
5619 swig_obj[0] = args;
5620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5621 if (!SWIG_IsOK(res1)) {
5622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5623 }
5624 arg1 = reinterpret_cast< wxPoint * >(argp1);
5625 result = (int) ((arg1)->y);
5626 resultobj = SWIG_From_int(static_cast< int >(result));
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5634 PyObject *resultobj = 0;
5635 int arg1 = (int) 0 ;
5636 int arg2 = (int) 0 ;
5637 wxPoint *result = 0 ;
5638 int val1 ;
5639 int ecode1 = 0 ;
5640 int val2 ;
5641 int ecode2 = 0 ;
5642 PyObject * obj0 = 0 ;
5643 PyObject * obj1 = 0 ;
5644 char * kwnames[] = {
5645 (char *) "x",(char *) "y", NULL
5646 };
5647
5648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5649 if (obj0) {
5650 ecode1 = SWIG_AsVal_int(obj0, &val1);
5651 if (!SWIG_IsOK(ecode1)) {
5652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5653 }
5654 arg1 = static_cast< int >(val1);
5655 }
5656 if (obj1) {
5657 ecode2 = SWIG_AsVal_int(obj1, &val2);
5658 if (!SWIG_IsOK(ecode2)) {
5659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5660 }
5661 arg2 = static_cast< int >(val2);
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 result = (wxPoint *)new wxPoint(arg1,arg2);
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5677 PyObject *resultobj = 0;
5678 wxPoint *arg1 = (wxPoint *) 0 ;
5679 void *argp1 = 0 ;
5680 int res1 = 0 ;
5681 PyObject *swig_obj[1] ;
5682
5683 if (!args) SWIG_fail;
5684 swig_obj[0] = args;
5685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5686 if (!SWIG_IsOK(res1)) {
5687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5688 }
5689 arg1 = reinterpret_cast< wxPoint * >(argp1);
5690 {
5691 PyThreadState* __tstate = wxPyBeginAllowThreads();
5692 delete arg1;
5693
5694 wxPyEndAllowThreads(__tstate);
5695 if (PyErr_Occurred()) SWIG_fail;
5696 }
5697 resultobj = SWIG_Py_Void();
5698 return resultobj;
5699 fail:
5700 return NULL;
5701 }
5702
5703
5704 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5705 PyObject *resultobj = 0;
5706 wxPoint *arg1 = (wxPoint *) 0 ;
5707 PyObject *arg2 = (PyObject *) 0 ;
5708 bool result;
5709 void *argp1 = 0 ;
5710 int res1 = 0 ;
5711 PyObject * obj0 = 0 ;
5712 PyObject * obj1 = 0 ;
5713 char * kwnames[] = {
5714 (char *) "self",(char *) "other", NULL
5715 };
5716
5717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5719 if (!SWIG_IsOK(res1)) {
5720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5721 }
5722 arg1 = reinterpret_cast< wxPoint * >(argp1);
5723 arg2 = obj1;
5724 {
5725 result = (bool)wxPoint___eq__(arg1,arg2);
5726 if (PyErr_Occurred()) SWIG_fail;
5727 }
5728 {
5729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5730 }
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5738 PyObject *resultobj = 0;
5739 wxPoint *arg1 = (wxPoint *) 0 ;
5740 PyObject *arg2 = (PyObject *) 0 ;
5741 bool result;
5742 void *argp1 = 0 ;
5743 int res1 = 0 ;
5744 PyObject * obj0 = 0 ;
5745 PyObject * obj1 = 0 ;
5746 char * kwnames[] = {
5747 (char *) "self",(char *) "other", NULL
5748 };
5749
5750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5752 if (!SWIG_IsOK(res1)) {
5753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5754 }
5755 arg1 = reinterpret_cast< wxPoint * >(argp1);
5756 arg2 = obj1;
5757 {
5758 result = (bool)wxPoint___ne__(arg1,arg2);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 {
5762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5763 }
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj = 0;
5772 wxPoint *arg1 = (wxPoint *) 0 ;
5773 wxPoint *arg2 = 0 ;
5774 wxPoint result;
5775 void *argp1 = 0 ;
5776 int res1 = 0 ;
5777 wxPoint temp2 ;
5778 PyObject * obj0 = 0 ;
5779 PyObject * obj1 = 0 ;
5780 char * kwnames[] = {
5781 (char *) "self",(char *) "pt", NULL
5782 };
5783
5784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5786 if (!SWIG_IsOK(res1)) {
5787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5788 }
5789 arg1 = reinterpret_cast< wxPoint * >(argp1);
5790 {
5791 arg2 = &temp2;
5792 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5793 }
5794 {
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 result = (arg1)->operator +((wxPoint const &)*arg2);
5797 wxPyEndAllowThreads(__tstate);
5798 if (PyErr_Occurred()) SWIG_fail;
5799 }
5800 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5808 PyObject *resultobj = 0;
5809 wxPoint *arg1 = (wxPoint *) 0 ;
5810 wxPoint *arg2 = 0 ;
5811 wxPoint result;
5812 void *argp1 = 0 ;
5813 int res1 = 0 ;
5814 wxPoint temp2 ;
5815 PyObject * obj0 = 0 ;
5816 PyObject * obj1 = 0 ;
5817 char * kwnames[] = {
5818 (char *) "self",(char *) "pt", NULL
5819 };
5820
5821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5823 if (!SWIG_IsOK(res1)) {
5824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5825 }
5826 arg1 = reinterpret_cast< wxPoint * >(argp1);
5827 {
5828 arg2 = &temp2;
5829 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5830 }
5831 {
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 result = (arg1)->operator -((wxPoint const &)*arg2);
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5838 return resultobj;
5839 fail:
5840 return NULL;
5841 }
5842
5843
5844 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5845 PyObject *resultobj = 0;
5846 wxPoint *arg1 = (wxPoint *) 0 ;
5847 wxPoint *arg2 = 0 ;
5848 wxPoint *result = 0 ;
5849 void *argp1 = 0 ;
5850 int res1 = 0 ;
5851 wxPoint temp2 ;
5852 PyObject * obj0 = 0 ;
5853 PyObject * obj1 = 0 ;
5854 char * kwnames[] = {
5855 (char *) "self",(char *) "pt", NULL
5856 };
5857
5858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5860 if (!SWIG_IsOK(res1)) {
5861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5862 }
5863 arg1 = reinterpret_cast< wxPoint * >(argp1);
5864 {
5865 arg2 = &temp2;
5866 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5867 }
5868 {
5869 PyThreadState* __tstate = wxPyBeginAllowThreads();
5870 {
5871 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5872 result = (wxPoint *) &_result_ref;
5873 }
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = 0;
5886 wxPoint *arg1 = (wxPoint *) 0 ;
5887 wxPoint *arg2 = 0 ;
5888 wxPoint *result = 0 ;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 wxPoint temp2 ;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 char * kwnames[] = {
5895 (char *) "self",(char *) "pt", NULL
5896 };
5897
5898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5900 if (!SWIG_IsOK(res1)) {
5901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5902 }
5903 arg1 = reinterpret_cast< wxPoint * >(argp1);
5904 {
5905 arg2 = &temp2;
5906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5907 }
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 {
5911 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5912 result = (wxPoint *) &_result_ref;
5913 }
5914 wxPyEndAllowThreads(__tstate);
5915 if (PyErr_Occurred()) SWIG_fail;
5916 }
5917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5918 return resultobj;
5919 fail:
5920 return NULL;
5921 }
5922
5923
5924 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5925 PyObject *resultobj = 0;
5926 wxPoint *arg1 = (wxPoint *) 0 ;
5927 long arg2 ;
5928 long arg3 ;
5929 void *argp1 = 0 ;
5930 int res1 = 0 ;
5931 long val2 ;
5932 int ecode2 = 0 ;
5933 long val3 ;
5934 int ecode3 = 0 ;
5935 PyObject * obj0 = 0 ;
5936 PyObject * obj1 = 0 ;
5937 PyObject * obj2 = 0 ;
5938 char * kwnames[] = {
5939 (char *) "self",(char *) "x",(char *) "y", NULL
5940 };
5941
5942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5944 if (!SWIG_IsOK(res1)) {
5945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5946 }
5947 arg1 = reinterpret_cast< wxPoint * >(argp1);
5948 ecode2 = SWIG_AsVal_long(obj1, &val2);
5949 if (!SWIG_IsOK(ecode2)) {
5950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5951 }
5952 arg2 = static_cast< long >(val2);
5953 ecode3 = SWIG_AsVal_long(obj2, &val3);
5954 if (!SWIG_IsOK(ecode3)) {
5955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5956 }
5957 arg3 = static_cast< long >(val3);
5958 {
5959 PyThreadState* __tstate = wxPyBeginAllowThreads();
5960 wxPoint_Set(arg1,arg2,arg3);
5961 wxPyEndAllowThreads(__tstate);
5962 if (PyErr_Occurred()) SWIG_fail;
5963 }
5964 resultobj = SWIG_Py_Void();
5965 return resultobj;
5966 fail:
5967 return NULL;
5968 }
5969
5970
5971 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5972 PyObject *resultobj = 0;
5973 wxPoint *arg1 = (wxPoint *) 0 ;
5974 PyObject *result = 0 ;
5975 void *argp1 = 0 ;
5976 int res1 = 0 ;
5977 PyObject *swig_obj[1] ;
5978
5979 if (!args) SWIG_fail;
5980 swig_obj[0] = args;
5981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5982 if (!SWIG_IsOK(res1)) {
5983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5984 }
5985 arg1 = reinterpret_cast< wxPoint * >(argp1);
5986 {
5987 PyThreadState* __tstate = wxPyBeginAllowThreads();
5988 result = (PyObject *)wxPoint_Get(arg1);
5989 wxPyEndAllowThreads(__tstate);
5990 if (PyErr_Occurred()) SWIG_fail;
5991 }
5992 resultobj = result;
5993 return resultobj;
5994 fail:
5995 return NULL;
5996 }
5997
5998
5999 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6000 PyObject *obj;
6001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6002 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6003 return SWIG_Py_Void();
6004 }
6005
6006 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6007 return SWIG_Python_InitShadowInstance(args);
6008 }
6009
6010 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj = 0;
6012 int arg1 = (int) 0 ;
6013 int arg2 = (int) 0 ;
6014 int arg3 = (int) 0 ;
6015 int arg4 = (int) 0 ;
6016 wxRect *result = 0 ;
6017 int val1 ;
6018 int ecode1 = 0 ;
6019 int val2 ;
6020 int ecode2 = 0 ;
6021 int val3 ;
6022 int ecode3 = 0 ;
6023 int val4 ;
6024 int ecode4 = 0 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 PyObject * obj2 = 0 ;
6028 PyObject * obj3 = 0 ;
6029 char * kwnames[] = {
6030 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6031 };
6032
6033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6034 if (obj0) {
6035 ecode1 = SWIG_AsVal_int(obj0, &val1);
6036 if (!SWIG_IsOK(ecode1)) {
6037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6038 }
6039 arg1 = static_cast< int >(val1);
6040 }
6041 if (obj1) {
6042 ecode2 = SWIG_AsVal_int(obj1, &val2);
6043 if (!SWIG_IsOK(ecode2)) {
6044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6045 }
6046 arg2 = static_cast< int >(val2);
6047 }
6048 if (obj2) {
6049 ecode3 = SWIG_AsVal_int(obj2, &val3);
6050 if (!SWIG_IsOK(ecode3)) {
6051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6052 }
6053 arg3 = static_cast< int >(val3);
6054 }
6055 if (obj3) {
6056 ecode4 = SWIG_AsVal_int(obj3, &val4);
6057 if (!SWIG_IsOK(ecode4)) {
6058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6059 }
6060 arg4 = static_cast< int >(val4);
6061 }
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj = 0;
6077 wxPoint *arg1 = 0 ;
6078 wxPoint *arg2 = 0 ;
6079 wxRect *result = 0 ;
6080 wxPoint temp1 ;
6081 wxPoint temp2 ;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 char * kwnames[] = {
6085 (char *) "topLeft",(char *) "bottomRight", NULL
6086 };
6087
6088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6089 {
6090 arg1 = &temp1;
6091 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6092 }
6093 {
6094 arg2 = &temp2;
6095 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6096 }
6097 {
6098 PyThreadState* __tstate = wxPyBeginAllowThreads();
6099 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6100 wxPyEndAllowThreads(__tstate);
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj = 0;
6112 wxPoint *arg1 = 0 ;
6113 wxSize *arg2 = 0 ;
6114 wxRect *result = 0 ;
6115 wxPoint temp1 ;
6116 wxSize temp2 ;
6117 PyObject * obj0 = 0 ;
6118 PyObject * obj1 = 0 ;
6119 char * kwnames[] = {
6120 (char *) "pos",(char *) "size", NULL
6121 };
6122
6123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6124 {
6125 arg1 = &temp1;
6126 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6127 }
6128 {
6129 arg2 = &temp2;
6130 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6131 }
6132 {
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6135 wxPyEndAllowThreads(__tstate);
6136 if (PyErr_Occurred()) SWIG_fail;
6137 }
6138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj = 0;
6147 wxSize *arg1 = 0 ;
6148 wxRect *result = 0 ;
6149 wxSize temp1 ;
6150 PyObject * obj0 = 0 ;
6151 char * kwnames[] = {
6152 (char *) "size", NULL
6153 };
6154
6155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6156 {
6157 arg1 = &temp1;
6158 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6159 }
6160 {
6161 PyThreadState* __tstate = wxPyBeginAllowThreads();
6162 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6163 wxPyEndAllowThreads(__tstate);
6164 if (PyErr_Occurred()) SWIG_fail;
6165 }
6166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6167 return resultobj;
6168 fail:
6169 return NULL;
6170 }
6171
6172
6173 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6174 PyObject *resultobj = 0;
6175 wxRect *arg1 = (wxRect *) 0 ;
6176 void *argp1 = 0 ;
6177 int res1 = 0 ;
6178 PyObject *swig_obj[1] ;
6179
6180 if (!args) SWIG_fail;
6181 swig_obj[0] = args;
6182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6183 if (!SWIG_IsOK(res1)) {
6184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6185 }
6186 arg1 = reinterpret_cast< wxRect * >(argp1);
6187 {
6188 PyThreadState* __tstate = wxPyBeginAllowThreads();
6189 delete arg1;
6190
6191 wxPyEndAllowThreads(__tstate);
6192 if (PyErr_Occurred()) SWIG_fail;
6193 }
6194 resultobj = SWIG_Py_Void();
6195 return resultobj;
6196 fail:
6197 return NULL;
6198 }
6199
6200
6201 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6202 PyObject *resultobj = 0;
6203 wxRect *arg1 = (wxRect *) 0 ;
6204 int result;
6205 void *argp1 = 0 ;
6206 int res1 = 0 ;
6207 PyObject *swig_obj[1] ;
6208
6209 if (!args) SWIG_fail;
6210 swig_obj[0] = args;
6211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6212 if (!SWIG_IsOK(res1)) {
6213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6214 }
6215 arg1 = reinterpret_cast< wxRect * >(argp1);
6216 {
6217 PyThreadState* __tstate = wxPyBeginAllowThreads();
6218 result = (int)((wxRect const *)arg1)->GetX();
6219 wxPyEndAllowThreads(__tstate);
6220 if (PyErr_Occurred()) SWIG_fail;
6221 }
6222 resultobj = SWIG_From_int(static_cast< int >(result));
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6230 PyObject *resultobj = 0;
6231 wxRect *arg1 = (wxRect *) 0 ;
6232 int arg2 ;
6233 void *argp1 = 0 ;
6234 int res1 = 0 ;
6235 int val2 ;
6236 int ecode2 = 0 ;
6237 PyObject * obj0 = 0 ;
6238 PyObject * obj1 = 0 ;
6239 char * kwnames[] = {
6240 (char *) "self",(char *) "x", NULL
6241 };
6242
6243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6245 if (!SWIG_IsOK(res1)) {
6246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6247 }
6248 arg1 = reinterpret_cast< wxRect * >(argp1);
6249 ecode2 = SWIG_AsVal_int(obj1, &val2);
6250 if (!SWIG_IsOK(ecode2)) {
6251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6252 }
6253 arg2 = static_cast< int >(val2);
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 (arg1)->SetX(arg2);
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_Py_Void();
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6268 PyObject *resultobj = 0;
6269 wxRect *arg1 = (wxRect *) 0 ;
6270 int result;
6271 void *argp1 = 0 ;
6272 int res1 = 0 ;
6273 PyObject *swig_obj[1] ;
6274
6275 if (!args) SWIG_fail;
6276 swig_obj[0] = args;
6277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6278 if (!SWIG_IsOK(res1)) {
6279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6280 }
6281 arg1 = reinterpret_cast< wxRect * >(argp1);
6282 {
6283 PyThreadState* __tstate = wxPyBeginAllowThreads();
6284 result = (int)(arg1)->GetY();
6285 wxPyEndAllowThreads(__tstate);
6286 if (PyErr_Occurred()) SWIG_fail;
6287 }
6288 resultobj = SWIG_From_int(static_cast< int >(result));
6289 return resultobj;
6290 fail:
6291 return NULL;
6292 }
6293
6294
6295 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6296 PyObject *resultobj = 0;
6297 wxRect *arg1 = (wxRect *) 0 ;
6298 int arg2 ;
6299 void *argp1 = 0 ;
6300 int res1 = 0 ;
6301 int val2 ;
6302 int ecode2 = 0 ;
6303 PyObject * obj0 = 0 ;
6304 PyObject * obj1 = 0 ;
6305 char * kwnames[] = {
6306 (char *) "self",(char *) "y", NULL
6307 };
6308
6309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6311 if (!SWIG_IsOK(res1)) {
6312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6313 }
6314 arg1 = reinterpret_cast< wxRect * >(argp1);
6315 ecode2 = SWIG_AsVal_int(obj1, &val2);
6316 if (!SWIG_IsOK(ecode2)) {
6317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6318 }
6319 arg2 = static_cast< int >(val2);
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 (arg1)->SetY(arg2);
6323 wxPyEndAllowThreads(__tstate);
6324 if (PyErr_Occurred()) SWIG_fail;
6325 }
6326 resultobj = SWIG_Py_Void();
6327 return resultobj;
6328 fail:
6329 return NULL;
6330 }
6331
6332
6333 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6334 PyObject *resultobj = 0;
6335 wxRect *arg1 = (wxRect *) 0 ;
6336 int result;
6337 void *argp1 = 0 ;
6338 int res1 = 0 ;
6339 PyObject *swig_obj[1] ;
6340
6341 if (!args) SWIG_fail;
6342 swig_obj[0] = args;
6343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6344 if (!SWIG_IsOK(res1)) {
6345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6346 }
6347 arg1 = reinterpret_cast< wxRect * >(argp1);
6348 {
6349 PyThreadState* __tstate = wxPyBeginAllowThreads();
6350 result = (int)((wxRect const *)arg1)->GetWidth();
6351 wxPyEndAllowThreads(__tstate);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 resultobj = SWIG_From_int(static_cast< int >(result));
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6362 PyObject *resultobj = 0;
6363 wxRect *arg1 = (wxRect *) 0 ;
6364 int arg2 ;
6365 void *argp1 = 0 ;
6366 int res1 = 0 ;
6367 int val2 ;
6368 int ecode2 = 0 ;
6369 PyObject * obj0 = 0 ;
6370 PyObject * obj1 = 0 ;
6371 char * kwnames[] = {
6372 (char *) "self",(char *) "w", NULL
6373 };
6374
6375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6377 if (!SWIG_IsOK(res1)) {
6378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6379 }
6380 arg1 = reinterpret_cast< wxRect * >(argp1);
6381 ecode2 = SWIG_AsVal_int(obj1, &val2);
6382 if (!SWIG_IsOK(ecode2)) {
6383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6384 }
6385 arg2 = static_cast< int >(val2);
6386 {
6387 PyThreadState* __tstate = wxPyBeginAllowThreads();
6388 (arg1)->SetWidth(arg2);
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = SWIG_Py_Void();
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6400 PyObject *resultobj = 0;
6401 wxRect *arg1 = (wxRect *) 0 ;
6402 int result;
6403 void *argp1 = 0 ;
6404 int res1 = 0 ;
6405 PyObject *swig_obj[1] ;
6406
6407 if (!args) SWIG_fail;
6408 swig_obj[0] = args;
6409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6410 if (!SWIG_IsOK(res1)) {
6411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6412 }
6413 arg1 = reinterpret_cast< wxRect * >(argp1);
6414 {
6415 PyThreadState* __tstate = wxPyBeginAllowThreads();
6416 result = (int)((wxRect const *)arg1)->GetHeight();
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 resultobj = SWIG_From_int(static_cast< int >(result));
6421 return resultobj;
6422 fail:
6423 return NULL;
6424 }
6425
6426
6427 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6428 PyObject *resultobj = 0;
6429 wxRect *arg1 = (wxRect *) 0 ;
6430 int arg2 ;
6431 void *argp1 = 0 ;
6432 int res1 = 0 ;
6433 int val2 ;
6434 int ecode2 = 0 ;
6435 PyObject * obj0 = 0 ;
6436 PyObject * obj1 = 0 ;
6437 char * kwnames[] = {
6438 (char *) "self",(char *) "h", NULL
6439 };
6440
6441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6443 if (!SWIG_IsOK(res1)) {
6444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6445 }
6446 arg1 = reinterpret_cast< wxRect * >(argp1);
6447 ecode2 = SWIG_AsVal_int(obj1, &val2);
6448 if (!SWIG_IsOK(ecode2)) {
6449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6450 }
6451 arg2 = static_cast< int >(val2);
6452 {
6453 PyThreadState* __tstate = wxPyBeginAllowThreads();
6454 (arg1)->SetHeight(arg2);
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = SWIG_Py_Void();
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6466 PyObject *resultobj = 0;
6467 wxRect *arg1 = (wxRect *) 0 ;
6468 wxPoint result;
6469 void *argp1 = 0 ;
6470 int res1 = 0 ;
6471 PyObject *swig_obj[1] ;
6472
6473 if (!args) SWIG_fail;
6474 swig_obj[0] = args;
6475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6476 if (!SWIG_IsOK(res1)) {
6477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6478 }
6479 arg1 = reinterpret_cast< wxRect * >(argp1);
6480 {
6481 PyThreadState* __tstate = wxPyBeginAllowThreads();
6482 result = ((wxRect const *)arg1)->GetPosition();
6483 wxPyEndAllowThreads(__tstate);
6484 if (PyErr_Occurred()) SWIG_fail;
6485 }
6486 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6487 return resultobj;
6488 fail:
6489 return NULL;
6490 }
6491
6492
6493 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6494 PyObject *resultobj = 0;
6495 wxRect *arg1 = (wxRect *) 0 ;
6496 wxPoint *arg2 = 0 ;
6497 void *argp1 = 0 ;
6498 int res1 = 0 ;
6499 wxPoint temp2 ;
6500 PyObject * obj0 = 0 ;
6501 PyObject * obj1 = 0 ;
6502 char * kwnames[] = {
6503 (char *) "self",(char *) "p", NULL
6504 };
6505
6506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6508 if (!SWIG_IsOK(res1)) {
6509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6510 }
6511 arg1 = reinterpret_cast< wxRect * >(argp1);
6512 {
6513 arg2 = &temp2;
6514 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6515 }
6516 {
6517 PyThreadState* __tstate = wxPyBeginAllowThreads();
6518 (arg1)->SetPosition((wxPoint const &)*arg2);
6519 wxPyEndAllowThreads(__tstate);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 resultobj = SWIG_Py_Void();
6523 return resultobj;
6524 fail:
6525 return NULL;
6526 }
6527
6528
6529 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6530 PyObject *resultobj = 0;
6531 wxRect *arg1 = (wxRect *) 0 ;
6532 wxSize result;
6533 void *argp1 = 0 ;
6534 int res1 = 0 ;
6535 PyObject *swig_obj[1] ;
6536
6537 if (!args) SWIG_fail;
6538 swig_obj[0] = args;
6539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6540 if (!SWIG_IsOK(res1)) {
6541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6542 }
6543 arg1 = reinterpret_cast< wxRect * >(argp1);
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 result = ((wxRect const *)arg1)->GetSize();
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj = 0;
6559 wxRect *arg1 = (wxRect *) 0 ;
6560 wxSize *arg2 = 0 ;
6561 void *argp1 = 0 ;
6562 int res1 = 0 ;
6563 wxSize temp2 ;
6564 PyObject * obj0 = 0 ;
6565 PyObject * obj1 = 0 ;
6566 char * kwnames[] = {
6567 (char *) "self",(char *) "s", NULL
6568 };
6569
6570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6572 if (!SWIG_IsOK(res1)) {
6573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6574 }
6575 arg1 = reinterpret_cast< wxRect * >(argp1);
6576 {
6577 arg2 = &temp2;
6578 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6579 }
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 (arg1)->SetSize((wxSize const &)*arg2);
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_Py_Void();
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6594 PyObject *resultobj = 0;
6595 wxRect *arg1 = (wxRect *) 0 ;
6596 bool result;
6597 void *argp1 = 0 ;
6598 int res1 = 0 ;
6599 PyObject *swig_obj[1] ;
6600
6601 if (!args) SWIG_fail;
6602 swig_obj[0] = args;
6603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6604 if (!SWIG_IsOK(res1)) {
6605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6606 }
6607 arg1 = reinterpret_cast< wxRect * >(argp1);
6608 {
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 result = (bool)((wxRect const *)arg1)->IsEmpty();
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 {
6615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6616 }
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6624 PyObject *resultobj = 0;
6625 wxRect *arg1 = (wxRect *) 0 ;
6626 wxPoint result;
6627 void *argp1 = 0 ;
6628 int res1 = 0 ;
6629 PyObject *swig_obj[1] ;
6630
6631 if (!args) SWIG_fail;
6632 swig_obj[0] = args;
6633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6634 if (!SWIG_IsOK(res1)) {
6635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6636 }
6637 arg1 = reinterpret_cast< wxRect * >(argp1);
6638 {
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 result = ((wxRect const *)arg1)->GetTopLeft();
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj = 0;
6653 wxRect *arg1 = (wxRect *) 0 ;
6654 wxPoint *arg2 = 0 ;
6655 void *argp1 = 0 ;
6656 int res1 = 0 ;
6657 wxPoint temp2 ;
6658 PyObject * obj0 = 0 ;
6659 PyObject * obj1 = 0 ;
6660 char * kwnames[] = {
6661 (char *) "self",(char *) "p", NULL
6662 };
6663
6664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6666 if (!SWIG_IsOK(res1)) {
6667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6668 }
6669 arg1 = reinterpret_cast< wxRect * >(argp1);
6670 {
6671 arg2 = &temp2;
6672 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6673 }
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6677 wxPyEndAllowThreads(__tstate);
6678 if (PyErr_Occurred()) SWIG_fail;
6679 }
6680 resultobj = SWIG_Py_Void();
6681 return resultobj;
6682 fail:
6683 return NULL;
6684 }
6685
6686
6687 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6688 PyObject *resultobj = 0;
6689 wxRect *arg1 = (wxRect *) 0 ;
6690 wxPoint result;
6691 void *argp1 = 0 ;
6692 int res1 = 0 ;
6693 PyObject *swig_obj[1] ;
6694
6695 if (!args) SWIG_fail;
6696 swig_obj[0] = args;
6697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6698 if (!SWIG_IsOK(res1)) {
6699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6700 }
6701 arg1 = reinterpret_cast< wxRect * >(argp1);
6702 {
6703 PyThreadState* __tstate = wxPyBeginAllowThreads();
6704 result = ((wxRect const *)arg1)->GetBottomRight();
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6716 PyObject *resultobj = 0;
6717 wxRect *arg1 = (wxRect *) 0 ;
6718 wxPoint *arg2 = 0 ;
6719 void *argp1 = 0 ;
6720 int res1 = 0 ;
6721 wxPoint temp2 ;
6722 PyObject * obj0 = 0 ;
6723 PyObject * obj1 = 0 ;
6724 char * kwnames[] = {
6725 (char *) "self",(char *) "p", NULL
6726 };
6727
6728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6730 if (!SWIG_IsOK(res1)) {
6731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6732 }
6733 arg1 = reinterpret_cast< wxRect * >(argp1);
6734 {
6735 arg2 = &temp2;
6736 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6737 }
6738 {
6739 PyThreadState* __tstate = wxPyBeginAllowThreads();
6740 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6741 wxPyEndAllowThreads(__tstate);
6742 if (PyErr_Occurred()) SWIG_fail;
6743 }
6744 resultobj = SWIG_Py_Void();
6745 return resultobj;
6746 fail:
6747 return NULL;
6748 }
6749
6750
6751 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6752 PyObject *resultobj = 0;
6753 wxRect *arg1 = (wxRect *) 0 ;
6754 int result;
6755 void *argp1 = 0 ;
6756 int res1 = 0 ;
6757 PyObject *swig_obj[1] ;
6758
6759 if (!args) SWIG_fail;
6760 swig_obj[0] = args;
6761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6762 if (!SWIG_IsOK(res1)) {
6763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6764 }
6765 arg1 = reinterpret_cast< wxRect * >(argp1);
6766 {
6767 PyThreadState* __tstate = wxPyBeginAllowThreads();
6768 result = (int)((wxRect const *)arg1)->GetLeft();
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 resultobj = SWIG_From_int(static_cast< int >(result));
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6780 PyObject *resultobj = 0;
6781 wxRect *arg1 = (wxRect *) 0 ;
6782 int result;
6783 void *argp1 = 0 ;
6784 int res1 = 0 ;
6785 PyObject *swig_obj[1] ;
6786
6787 if (!args) SWIG_fail;
6788 swig_obj[0] = args;
6789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6790 if (!SWIG_IsOK(res1)) {
6791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6792 }
6793 arg1 = reinterpret_cast< wxRect * >(argp1);
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 result = (int)((wxRect const *)arg1)->GetTop();
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 resultobj = SWIG_From_int(static_cast< int >(result));
6801 return resultobj;
6802 fail:
6803 return NULL;
6804 }
6805
6806
6807 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6808 PyObject *resultobj = 0;
6809 wxRect *arg1 = (wxRect *) 0 ;
6810 int result;
6811 void *argp1 = 0 ;
6812 int res1 = 0 ;
6813 PyObject *swig_obj[1] ;
6814
6815 if (!args) SWIG_fail;
6816 swig_obj[0] = args;
6817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6818 if (!SWIG_IsOK(res1)) {
6819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6820 }
6821 arg1 = reinterpret_cast< wxRect * >(argp1);
6822 {
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 result = (int)((wxRect const *)arg1)->GetBottom();
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 resultobj = SWIG_From_int(static_cast< int >(result));
6829 return resultobj;
6830 fail:
6831 return NULL;
6832 }
6833
6834
6835 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6836 PyObject *resultobj = 0;
6837 wxRect *arg1 = (wxRect *) 0 ;
6838 int result;
6839 void *argp1 = 0 ;
6840 int res1 = 0 ;
6841 PyObject *swig_obj[1] ;
6842
6843 if (!args) SWIG_fail;
6844 swig_obj[0] = args;
6845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6846 if (!SWIG_IsOK(res1)) {
6847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6848 }
6849 arg1 = reinterpret_cast< wxRect * >(argp1);
6850 {
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 result = (int)((wxRect const *)arg1)->GetRight();
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_From_int(static_cast< int >(result));
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6864 PyObject *resultobj = 0;
6865 wxRect *arg1 = (wxRect *) 0 ;
6866 int arg2 ;
6867 void *argp1 = 0 ;
6868 int res1 = 0 ;
6869 int val2 ;
6870 int ecode2 = 0 ;
6871 PyObject * obj0 = 0 ;
6872 PyObject * obj1 = 0 ;
6873 char * kwnames[] = {
6874 (char *) "self",(char *) "left", NULL
6875 };
6876
6877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6879 if (!SWIG_IsOK(res1)) {
6880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6881 }
6882 arg1 = reinterpret_cast< wxRect * >(argp1);
6883 ecode2 = SWIG_AsVal_int(obj1, &val2);
6884 if (!SWIG_IsOK(ecode2)) {
6885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6886 }
6887 arg2 = static_cast< int >(val2);
6888 {
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 (arg1)->SetLeft(arg2);
6891 wxPyEndAllowThreads(__tstate);
6892 if (PyErr_Occurred()) SWIG_fail;
6893 }
6894 resultobj = SWIG_Py_Void();
6895 return resultobj;
6896 fail:
6897 return NULL;
6898 }
6899
6900
6901 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6902 PyObject *resultobj = 0;
6903 wxRect *arg1 = (wxRect *) 0 ;
6904 int arg2 ;
6905 void *argp1 = 0 ;
6906 int res1 = 0 ;
6907 int val2 ;
6908 int ecode2 = 0 ;
6909 PyObject * obj0 = 0 ;
6910 PyObject * obj1 = 0 ;
6911 char * kwnames[] = {
6912 (char *) "self",(char *) "right", NULL
6913 };
6914
6915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6917 if (!SWIG_IsOK(res1)) {
6918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6919 }
6920 arg1 = reinterpret_cast< wxRect * >(argp1);
6921 ecode2 = SWIG_AsVal_int(obj1, &val2);
6922 if (!SWIG_IsOK(ecode2)) {
6923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6924 }
6925 arg2 = static_cast< int >(val2);
6926 {
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 (arg1)->SetRight(arg2);
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 resultobj = SWIG_Py_Void();
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj = 0;
6941 wxRect *arg1 = (wxRect *) 0 ;
6942 int arg2 ;
6943 void *argp1 = 0 ;
6944 int res1 = 0 ;
6945 int val2 ;
6946 int ecode2 = 0 ;
6947 PyObject * obj0 = 0 ;
6948 PyObject * obj1 = 0 ;
6949 char * kwnames[] = {
6950 (char *) "self",(char *) "top", NULL
6951 };
6952
6953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6955 if (!SWIG_IsOK(res1)) {
6956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6957 }
6958 arg1 = reinterpret_cast< wxRect * >(argp1);
6959 ecode2 = SWIG_AsVal_int(obj1, &val2);
6960 if (!SWIG_IsOK(ecode2)) {
6961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6962 }
6963 arg2 = static_cast< int >(val2);
6964 {
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 (arg1)->SetTop(arg2);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6978 PyObject *resultobj = 0;
6979 wxRect *arg1 = (wxRect *) 0 ;
6980 int arg2 ;
6981 void *argp1 = 0 ;
6982 int res1 = 0 ;
6983 int val2 ;
6984 int ecode2 = 0 ;
6985 PyObject * obj0 = 0 ;
6986 PyObject * obj1 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "self",(char *) "bottom", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6993 if (!SWIG_IsOK(res1)) {
6994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6995 }
6996 arg1 = reinterpret_cast< wxRect * >(argp1);
6997 ecode2 = SWIG_AsVal_int(obj1, &val2);
6998 if (!SWIG_IsOK(ecode2)) {
6999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7000 }
7001 arg2 = static_cast< int >(val2);
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 (arg1)->SetBottom(arg2);
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_Py_Void();
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj = 0;
7017 wxRect *arg1 = (wxRect *) 0 ;
7018 int arg2 ;
7019 int arg3 ;
7020 wxRect *result = 0 ;
7021 void *argp1 = 0 ;
7022 int res1 = 0 ;
7023 int val2 ;
7024 int ecode2 = 0 ;
7025 int val3 ;
7026 int ecode3 = 0 ;
7027 PyObject * obj0 = 0 ;
7028 PyObject * obj1 = 0 ;
7029 PyObject * obj2 = 0 ;
7030 char * kwnames[] = {
7031 (char *) "self",(char *) "dx",(char *) "dy", NULL
7032 };
7033
7034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7036 if (!SWIG_IsOK(res1)) {
7037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7038 }
7039 arg1 = reinterpret_cast< wxRect * >(argp1);
7040 ecode2 = SWIG_AsVal_int(obj1, &val2);
7041 if (!SWIG_IsOK(ecode2)) {
7042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7043 }
7044 arg2 = static_cast< int >(val2);
7045 ecode3 = SWIG_AsVal_int(obj2, &val3);
7046 if (!SWIG_IsOK(ecode3)) {
7047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7048 }
7049 arg3 = static_cast< int >(val3);
7050 {
7051 PyThreadState* __tstate = wxPyBeginAllowThreads();
7052 {
7053 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7054 result = (wxRect *) &_result_ref;
7055 }
7056 wxPyEndAllowThreads(__tstate);
7057 if (PyErr_Occurred()) SWIG_fail;
7058 }
7059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7060 return resultobj;
7061 fail:
7062 return NULL;
7063 }
7064
7065
7066 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7067 PyObject *resultobj = 0;
7068 wxRect *arg1 = (wxRect *) 0 ;
7069 int arg2 ;
7070 int arg3 ;
7071 wxRect *result = 0 ;
7072 void *argp1 = 0 ;
7073 int res1 = 0 ;
7074 int val2 ;
7075 int ecode2 = 0 ;
7076 int val3 ;
7077 int ecode3 = 0 ;
7078 PyObject * obj0 = 0 ;
7079 PyObject * obj1 = 0 ;
7080 PyObject * obj2 = 0 ;
7081 char * kwnames[] = {
7082 (char *) "self",(char *) "dx",(char *) "dy", NULL
7083 };
7084
7085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7089 }
7090 arg1 = reinterpret_cast< wxRect * >(argp1);
7091 ecode2 = SWIG_AsVal_int(obj1, &val2);
7092 if (!SWIG_IsOK(ecode2)) {
7093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7094 }
7095 arg2 = static_cast< int >(val2);
7096 ecode3 = SWIG_AsVal_int(obj2, &val3);
7097 if (!SWIG_IsOK(ecode3)) {
7098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7099 }
7100 arg3 = static_cast< int >(val3);
7101 {
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 {
7104 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7105 result = (wxRect *) &_result_ref;
7106 }
7107 wxPyEndAllowThreads(__tstate);
7108 if (PyErr_Occurred()) SWIG_fail;
7109 }
7110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7111 return resultobj;
7112 fail:
7113 return NULL;
7114 }
7115
7116
7117 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7118 PyObject *resultobj = 0;
7119 wxRect *arg1 = (wxRect *) 0 ;
7120 int arg2 ;
7121 int arg3 ;
7122 void *argp1 = 0 ;
7123 int res1 = 0 ;
7124 int val2 ;
7125 int ecode2 = 0 ;
7126 int val3 ;
7127 int ecode3 = 0 ;
7128 PyObject * obj0 = 0 ;
7129 PyObject * obj1 = 0 ;
7130 PyObject * obj2 = 0 ;
7131 char * kwnames[] = {
7132 (char *) "self",(char *) "dx",(char *) "dy", NULL
7133 };
7134
7135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7137 if (!SWIG_IsOK(res1)) {
7138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7139 }
7140 arg1 = reinterpret_cast< wxRect * >(argp1);
7141 ecode2 = SWIG_AsVal_int(obj1, &val2);
7142 if (!SWIG_IsOK(ecode2)) {
7143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7144 }
7145 arg2 = static_cast< int >(val2);
7146 ecode3 = SWIG_AsVal_int(obj2, &val3);
7147 if (!SWIG_IsOK(ecode3)) {
7148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7149 }
7150 arg3 = static_cast< int >(val3);
7151 {
7152 PyThreadState* __tstate = wxPyBeginAllowThreads();
7153 (arg1)->Offset(arg2,arg3);
7154 wxPyEndAllowThreads(__tstate);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_Py_Void();
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxRect *arg1 = (wxRect *) 0 ;
7167 wxPoint *arg2 = 0 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 wxPoint temp2 ;
7171 PyObject * obj0 = 0 ;
7172 PyObject * obj1 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "self",(char *) "pt", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7179 if (!SWIG_IsOK(res1)) {
7180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7181 }
7182 arg1 = reinterpret_cast< wxRect * >(argp1);
7183 {
7184 arg2 = &temp2;
7185 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7186 }
7187 {
7188 PyThreadState* __tstate = wxPyBeginAllowThreads();
7189 (arg1)->Offset((wxPoint const &)*arg2);
7190 wxPyEndAllowThreads(__tstate);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 resultobj = SWIG_Py_Void();
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj = 0;
7202 wxRect *arg1 = (wxRect *) 0 ;
7203 wxRect *arg2 = 0 ;
7204 wxRect result;
7205 void *argp1 = 0 ;
7206 int res1 = 0 ;
7207 wxRect temp2 ;
7208 PyObject * obj0 = 0 ;
7209 PyObject * obj1 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "self",(char *) "rect", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7216 if (!SWIG_IsOK(res1)) {
7217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7218 }
7219 arg1 = reinterpret_cast< wxRect * >(argp1);
7220 {
7221 arg2 = &temp2;
7222 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7223 }
7224 {
7225 PyThreadState* __tstate = wxPyBeginAllowThreads();
7226 result = (arg1)->Intersect((wxRect const &)*arg2);
7227 wxPyEndAllowThreads(__tstate);
7228 if (PyErr_Occurred()) SWIG_fail;
7229 }
7230 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj = 0;
7239 wxRect *arg1 = (wxRect *) 0 ;
7240 wxRect *arg2 = 0 ;
7241 wxRect result;
7242 void *argp1 = 0 ;
7243 int res1 = 0 ;
7244 wxRect temp2 ;
7245 PyObject * obj0 = 0 ;
7246 PyObject * obj1 = 0 ;
7247 char * kwnames[] = {
7248 (char *) "self",(char *) "rect", NULL
7249 };
7250
7251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7253 if (!SWIG_IsOK(res1)) {
7254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7255 }
7256 arg1 = reinterpret_cast< wxRect * >(argp1);
7257 {
7258 arg2 = &temp2;
7259 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7260 }
7261 {
7262 PyThreadState* __tstate = wxPyBeginAllowThreads();
7263 result = (arg1)->Union((wxRect const &)*arg2);
7264 wxPyEndAllowThreads(__tstate);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7268 return resultobj;
7269 fail:
7270 return NULL;
7271 }
7272
7273
7274 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7275 PyObject *resultobj = 0;
7276 wxRect *arg1 = (wxRect *) 0 ;
7277 wxRect *arg2 = 0 ;
7278 wxRect result;
7279 void *argp1 = 0 ;
7280 int res1 = 0 ;
7281 wxRect temp2 ;
7282 PyObject * obj0 = 0 ;
7283 PyObject * obj1 = 0 ;
7284 char * kwnames[] = {
7285 (char *) "self",(char *) "rect", NULL
7286 };
7287
7288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7290 if (!SWIG_IsOK(res1)) {
7291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7292 }
7293 arg1 = reinterpret_cast< wxRect * >(argp1);
7294 {
7295 arg2 = &temp2;
7296 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7297 }
7298 {
7299 PyThreadState* __tstate = wxPyBeginAllowThreads();
7300 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7301 wxPyEndAllowThreads(__tstate);
7302 if (PyErr_Occurred()) SWIG_fail;
7303 }
7304 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7305 return resultobj;
7306 fail:
7307 return NULL;
7308 }
7309
7310
7311 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7312 PyObject *resultobj = 0;
7313 wxRect *arg1 = (wxRect *) 0 ;
7314 wxRect *arg2 = 0 ;
7315 wxRect *result = 0 ;
7316 void *argp1 = 0 ;
7317 int res1 = 0 ;
7318 wxRect temp2 ;
7319 PyObject * obj0 = 0 ;
7320 PyObject * obj1 = 0 ;
7321 char * kwnames[] = {
7322 (char *) "self",(char *) "rect", NULL
7323 };
7324
7325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7327 if (!SWIG_IsOK(res1)) {
7328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7329 }
7330 arg1 = reinterpret_cast< wxRect * >(argp1);
7331 {
7332 arg2 = &temp2;
7333 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7334 }
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 {
7338 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7339 result = (wxRect *) &_result_ref;
7340 }
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 PyObject *arg2 = (PyObject *) 0 ;
7355 bool result;
7356 void *argp1 = 0 ;
7357 int res1 = 0 ;
7358 PyObject * obj0 = 0 ;
7359 PyObject * obj1 = 0 ;
7360 char * kwnames[] = {
7361 (char *) "self",(char *) "other", NULL
7362 };
7363
7364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7366 if (!SWIG_IsOK(res1)) {
7367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7368 }
7369 arg1 = reinterpret_cast< wxRect * >(argp1);
7370 arg2 = obj1;
7371 {
7372 result = (bool)wxRect___eq__(arg1,arg2);
7373 if (PyErr_Occurred()) SWIG_fail;
7374 }
7375 {
7376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7377 }
7378 return resultobj;
7379 fail:
7380 return NULL;
7381 }
7382
7383
7384 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7385 PyObject *resultobj = 0;
7386 wxRect *arg1 = (wxRect *) 0 ;
7387 PyObject *arg2 = (PyObject *) 0 ;
7388 bool result;
7389 void *argp1 = 0 ;
7390 int res1 = 0 ;
7391 PyObject * obj0 = 0 ;
7392 PyObject * obj1 = 0 ;
7393 char * kwnames[] = {
7394 (char *) "self",(char *) "other", NULL
7395 };
7396
7397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7399 if (!SWIG_IsOK(res1)) {
7400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7401 }
7402 arg1 = reinterpret_cast< wxRect * >(argp1);
7403 arg2 = obj1;
7404 {
7405 result = (bool)wxRect___ne__(arg1,arg2);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 {
7409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7410 }
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7418 PyObject *resultobj = 0;
7419 wxRect *arg1 = (wxRect *) 0 ;
7420 int arg2 ;
7421 int arg3 ;
7422 bool result;
7423 void *argp1 = 0 ;
7424 int res1 = 0 ;
7425 int val2 ;
7426 int ecode2 = 0 ;
7427 int val3 ;
7428 int ecode3 = 0 ;
7429 PyObject * obj0 = 0 ;
7430 PyObject * obj1 = 0 ;
7431 PyObject * obj2 = 0 ;
7432 char * kwnames[] = {
7433 (char *) "self",(char *) "x",(char *) "y", NULL
7434 };
7435
7436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7438 if (!SWIG_IsOK(res1)) {
7439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7440 }
7441 arg1 = reinterpret_cast< wxRect * >(argp1);
7442 ecode2 = SWIG_AsVal_int(obj1, &val2);
7443 if (!SWIG_IsOK(ecode2)) {
7444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7445 }
7446 arg2 = static_cast< int >(val2);
7447 ecode3 = SWIG_AsVal_int(obj2, &val3);
7448 if (!SWIG_IsOK(ecode3)) {
7449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7450 }
7451 arg3 = static_cast< int >(val3);
7452 {
7453 PyThreadState* __tstate = wxPyBeginAllowThreads();
7454 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7455 wxPyEndAllowThreads(__tstate);
7456 if (PyErr_Occurred()) SWIG_fail;
7457 }
7458 {
7459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7460 }
7461 return resultobj;
7462 fail:
7463 return NULL;
7464 }
7465
7466
7467 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7468 PyObject *resultobj = 0;
7469 wxRect *arg1 = (wxRect *) 0 ;
7470 wxPoint *arg2 = 0 ;
7471 bool result;
7472 void *argp1 = 0 ;
7473 int res1 = 0 ;
7474 wxPoint temp2 ;
7475 PyObject * obj0 = 0 ;
7476 PyObject * obj1 = 0 ;
7477 char * kwnames[] = {
7478 (char *) "self",(char *) "pt", NULL
7479 };
7480
7481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7483 if (!SWIG_IsOK(res1)) {
7484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7485 }
7486 arg1 = reinterpret_cast< wxRect * >(argp1);
7487 {
7488 arg2 = &temp2;
7489 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7490 }
7491 {
7492 PyThreadState* __tstate = wxPyBeginAllowThreads();
7493 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7494 wxPyEndAllowThreads(__tstate);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 {
7498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7499 }
7500 return resultobj;
7501 fail:
7502 return NULL;
7503 }
7504
7505
7506 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7507 PyObject *resultobj = 0;
7508 wxRect *arg1 = (wxRect *) 0 ;
7509 wxRect *arg2 = 0 ;
7510 bool result;
7511 void *argp1 = 0 ;
7512 int res1 = 0 ;
7513 wxRect temp2 ;
7514 PyObject * obj0 = 0 ;
7515 PyObject * obj1 = 0 ;
7516 char * kwnames[] = {
7517 (char *) "self",(char *) "rect", NULL
7518 };
7519
7520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7522 if (!SWIG_IsOK(res1)) {
7523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7524 }
7525 arg1 = reinterpret_cast< wxRect * >(argp1);
7526 {
7527 arg2 = &temp2;
7528 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7529 }
7530 {
7531 PyThreadState* __tstate = wxPyBeginAllowThreads();
7532 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7533 wxPyEndAllowThreads(__tstate);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 {
7537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7538 }
7539 return resultobj;
7540 fail:
7541 return NULL;
7542 }
7543
7544
7545 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7546 PyObject *resultobj = 0;
7547 wxRect *arg1 = (wxRect *) 0 ;
7548 wxRect *arg2 = 0 ;
7549 int arg3 = (int) wxBOTH ;
7550 wxRect result;
7551 void *argp1 = 0 ;
7552 int res1 = 0 ;
7553 wxRect temp2 ;
7554 int val3 ;
7555 int ecode3 = 0 ;
7556 PyObject * obj0 = 0 ;
7557 PyObject * obj1 = 0 ;
7558 PyObject * obj2 = 0 ;
7559 char * kwnames[] = {
7560 (char *) "self",(char *) "r",(char *) "dir", NULL
7561 };
7562
7563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7567 }
7568 arg1 = reinterpret_cast< wxRect * >(argp1);
7569 {
7570 arg2 = &temp2;
7571 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7572 }
7573 if (obj2) {
7574 ecode3 = SWIG_AsVal_int(obj2, &val3);
7575 if (!SWIG_IsOK(ecode3)) {
7576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7577 }
7578 arg3 = static_cast< int >(val3);
7579 }
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7587 return resultobj;
7588 fail:
7589 return NULL;
7590 }
7591
7592
7593 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7594 PyObject *resultobj = 0;
7595 wxRect *arg1 = (wxRect *) 0 ;
7596 int arg2 ;
7597 void *argp1 = 0 ;
7598 int res1 = 0 ;
7599 int val2 ;
7600 int ecode2 = 0 ;
7601 PyObject *swig_obj[2] ;
7602
7603 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7605 if (!SWIG_IsOK(res1)) {
7606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7607 }
7608 arg1 = reinterpret_cast< wxRect * >(argp1);
7609 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7610 if (!SWIG_IsOK(ecode2)) {
7611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7612 }
7613 arg2 = static_cast< int >(val2);
7614 if (arg1) (arg1)->x = arg2;
7615
7616 resultobj = SWIG_Py_Void();
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7624 PyObject *resultobj = 0;
7625 wxRect *arg1 = (wxRect *) 0 ;
7626 int result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 PyObject *swig_obj[1] ;
7630
7631 if (!args) SWIG_fail;
7632 swig_obj[0] = args;
7633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7634 if (!SWIG_IsOK(res1)) {
7635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7636 }
7637 arg1 = reinterpret_cast< wxRect * >(argp1);
7638 result = (int) ((arg1)->x);
7639 resultobj = SWIG_From_int(static_cast< int >(result));
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7647 PyObject *resultobj = 0;
7648 wxRect *arg1 = (wxRect *) 0 ;
7649 int arg2 ;
7650 void *argp1 = 0 ;
7651 int res1 = 0 ;
7652 int val2 ;
7653 int ecode2 = 0 ;
7654 PyObject *swig_obj[2] ;
7655
7656 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7658 if (!SWIG_IsOK(res1)) {
7659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7660 }
7661 arg1 = reinterpret_cast< wxRect * >(argp1);
7662 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7663 if (!SWIG_IsOK(ecode2)) {
7664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7665 }
7666 arg2 = static_cast< int >(val2);
7667 if (arg1) (arg1)->y = arg2;
7668
7669 resultobj = SWIG_Py_Void();
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7677 PyObject *resultobj = 0;
7678 wxRect *arg1 = (wxRect *) 0 ;
7679 int result;
7680 void *argp1 = 0 ;
7681 int res1 = 0 ;
7682 PyObject *swig_obj[1] ;
7683
7684 if (!args) SWIG_fail;
7685 swig_obj[0] = args;
7686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7687 if (!SWIG_IsOK(res1)) {
7688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7689 }
7690 arg1 = reinterpret_cast< wxRect * >(argp1);
7691 result = (int) ((arg1)->y);
7692 resultobj = SWIG_From_int(static_cast< int >(result));
7693 return resultobj;
7694 fail:
7695 return NULL;
7696 }
7697
7698
7699 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7700 PyObject *resultobj = 0;
7701 wxRect *arg1 = (wxRect *) 0 ;
7702 int arg2 ;
7703 void *argp1 = 0 ;
7704 int res1 = 0 ;
7705 int val2 ;
7706 int ecode2 = 0 ;
7707 PyObject *swig_obj[2] ;
7708
7709 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7711 if (!SWIG_IsOK(res1)) {
7712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7713 }
7714 arg1 = reinterpret_cast< wxRect * >(argp1);
7715 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7716 if (!SWIG_IsOK(ecode2)) {
7717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7718 }
7719 arg2 = static_cast< int >(val2);
7720 if (arg1) (arg1)->width = arg2;
7721
7722 resultobj = SWIG_Py_Void();
7723 return resultobj;
7724 fail:
7725 return NULL;
7726 }
7727
7728
7729 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7730 PyObject *resultobj = 0;
7731 wxRect *arg1 = (wxRect *) 0 ;
7732 int result;
7733 void *argp1 = 0 ;
7734 int res1 = 0 ;
7735 PyObject *swig_obj[1] ;
7736
7737 if (!args) SWIG_fail;
7738 swig_obj[0] = args;
7739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7740 if (!SWIG_IsOK(res1)) {
7741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7742 }
7743 arg1 = reinterpret_cast< wxRect * >(argp1);
7744 result = (int) ((arg1)->width);
7745 resultobj = SWIG_From_int(static_cast< int >(result));
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7753 PyObject *resultobj = 0;
7754 wxRect *arg1 = (wxRect *) 0 ;
7755 int arg2 ;
7756 void *argp1 = 0 ;
7757 int res1 = 0 ;
7758 int val2 ;
7759 int ecode2 = 0 ;
7760 PyObject *swig_obj[2] ;
7761
7762 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7764 if (!SWIG_IsOK(res1)) {
7765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7766 }
7767 arg1 = reinterpret_cast< wxRect * >(argp1);
7768 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7769 if (!SWIG_IsOK(ecode2)) {
7770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7771 }
7772 arg2 = static_cast< int >(val2);
7773 if (arg1) (arg1)->height = arg2;
7774
7775 resultobj = SWIG_Py_Void();
7776 return resultobj;
7777 fail:
7778 return NULL;
7779 }
7780
7781
7782 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7783 PyObject *resultobj = 0;
7784 wxRect *arg1 = (wxRect *) 0 ;
7785 int result;
7786 void *argp1 = 0 ;
7787 int res1 = 0 ;
7788 PyObject *swig_obj[1] ;
7789
7790 if (!args) SWIG_fail;
7791 swig_obj[0] = args;
7792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7793 if (!SWIG_IsOK(res1)) {
7794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7795 }
7796 arg1 = reinterpret_cast< wxRect * >(argp1);
7797 result = (int) ((arg1)->height);
7798 resultobj = SWIG_From_int(static_cast< int >(result));
7799 return resultobj;
7800 fail:
7801 return NULL;
7802 }
7803
7804
7805 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7806 PyObject *resultobj = 0;
7807 wxRect *arg1 = (wxRect *) 0 ;
7808 int arg2 = (int) 0 ;
7809 int arg3 = (int) 0 ;
7810 int arg4 = (int) 0 ;
7811 int arg5 = (int) 0 ;
7812 void *argp1 = 0 ;
7813 int res1 = 0 ;
7814 int val2 ;
7815 int ecode2 = 0 ;
7816 int val3 ;
7817 int ecode3 = 0 ;
7818 int val4 ;
7819 int ecode4 = 0 ;
7820 int val5 ;
7821 int ecode5 = 0 ;
7822 PyObject * obj0 = 0 ;
7823 PyObject * obj1 = 0 ;
7824 PyObject * obj2 = 0 ;
7825 PyObject * obj3 = 0 ;
7826 PyObject * obj4 = 0 ;
7827 char * kwnames[] = {
7828 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7829 };
7830
7831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7833 if (!SWIG_IsOK(res1)) {
7834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7835 }
7836 arg1 = reinterpret_cast< wxRect * >(argp1);
7837 if (obj1) {
7838 ecode2 = SWIG_AsVal_int(obj1, &val2);
7839 if (!SWIG_IsOK(ecode2)) {
7840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7841 }
7842 arg2 = static_cast< int >(val2);
7843 }
7844 if (obj2) {
7845 ecode3 = SWIG_AsVal_int(obj2, &val3);
7846 if (!SWIG_IsOK(ecode3)) {
7847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7848 }
7849 arg3 = static_cast< int >(val3);
7850 }
7851 if (obj3) {
7852 ecode4 = SWIG_AsVal_int(obj3, &val4);
7853 if (!SWIG_IsOK(ecode4)) {
7854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7855 }
7856 arg4 = static_cast< int >(val4);
7857 }
7858 if (obj4) {
7859 ecode5 = SWIG_AsVal_int(obj4, &val5);
7860 if (!SWIG_IsOK(ecode5)) {
7861 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7862 }
7863 arg5 = static_cast< int >(val5);
7864 }
7865 {
7866 PyThreadState* __tstate = wxPyBeginAllowThreads();
7867 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7868 wxPyEndAllowThreads(__tstate);
7869 if (PyErr_Occurred()) SWIG_fail;
7870 }
7871 resultobj = SWIG_Py_Void();
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7879 PyObject *resultobj = 0;
7880 wxRect *arg1 = (wxRect *) 0 ;
7881 PyObject *result = 0 ;
7882 void *argp1 = 0 ;
7883 int res1 = 0 ;
7884 PyObject *swig_obj[1] ;
7885
7886 if (!args) SWIG_fail;
7887 swig_obj[0] = args;
7888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7889 if (!SWIG_IsOK(res1)) {
7890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7891 }
7892 arg1 = reinterpret_cast< wxRect * >(argp1);
7893 {
7894 PyThreadState* __tstate = wxPyBeginAllowThreads();
7895 result = (PyObject *)wxRect_Get(arg1);
7896 wxPyEndAllowThreads(__tstate);
7897 if (PyErr_Occurred()) SWIG_fail;
7898 }
7899 resultobj = result;
7900 return resultobj;
7901 fail:
7902 return NULL;
7903 }
7904
7905
7906 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7907 PyObject *obj;
7908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7909 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7910 return SWIG_Py_Void();
7911 }
7912
7913 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7914 return SWIG_Python_InitShadowInstance(args);
7915 }
7916
7917 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7918 PyObject *resultobj = 0;
7919 wxRect *arg1 = (wxRect *) 0 ;
7920 wxRect *arg2 = (wxRect *) 0 ;
7921 PyObject *result = 0 ;
7922 void *argp1 = 0 ;
7923 int res1 = 0 ;
7924 void *argp2 = 0 ;
7925 int res2 = 0 ;
7926 PyObject * obj0 = 0 ;
7927 PyObject * obj1 = 0 ;
7928 char * kwnames[] = {
7929 (char *) "r1",(char *) "r2", NULL
7930 };
7931
7932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) 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 '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7936 }
7937 arg1 = reinterpret_cast< wxRect * >(argp1);
7938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7939 if (!SWIG_IsOK(res2)) {
7940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7941 }
7942 arg2 = reinterpret_cast< wxRect * >(argp2);
7943 {
7944 if (!wxPyCheckForApp()) SWIG_fail;
7945 PyThreadState* __tstate = wxPyBeginAllowThreads();
7946 result = (PyObject *)wxIntersectRect(arg1,arg2);
7947 wxPyEndAllowThreads(__tstate);
7948 if (PyErr_Occurred()) SWIG_fail;
7949 }
7950 resultobj = result;
7951 return resultobj;
7952 fail:
7953 return NULL;
7954 }
7955
7956
7957 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7958 PyObject *resultobj = 0;
7959 double arg1 = (double) 0.0 ;
7960 double arg2 = (double) 0.0 ;
7961 wxPoint2D *result = 0 ;
7962 double val1 ;
7963 int ecode1 = 0 ;
7964 double val2 ;
7965 int ecode2 = 0 ;
7966 PyObject * obj0 = 0 ;
7967 PyObject * obj1 = 0 ;
7968 char * kwnames[] = {
7969 (char *) "x",(char *) "y", NULL
7970 };
7971
7972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7973 if (obj0) {
7974 ecode1 = SWIG_AsVal_double(obj0, &val1);
7975 if (!SWIG_IsOK(ecode1)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7977 }
7978 arg1 = static_cast< double >(val1);
7979 }
7980 if (obj1) {
7981 ecode2 = SWIG_AsVal_double(obj1, &val2);
7982 if (!SWIG_IsOK(ecode2)) {
7983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7984 }
7985 arg2 = static_cast< double >(val2);
7986 }
7987 {
7988 PyThreadState* __tstate = wxPyBeginAllowThreads();
7989 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7990 wxPyEndAllowThreads(__tstate);
7991 if (PyErr_Occurred()) SWIG_fail;
7992 }
7993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7994 return resultobj;
7995 fail:
7996 return NULL;
7997 }
7998
7999
8000 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8001 PyObject *resultobj = 0;
8002 wxPoint2D *arg1 = 0 ;
8003 wxPoint2D *result = 0 ;
8004 wxPoint2D temp1 ;
8005 PyObject * obj0 = 0 ;
8006 char * kwnames[] = {
8007 (char *) "pt", NULL
8008 };
8009
8010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8011 {
8012 arg1 = &temp1;
8013 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8014 }
8015 {
8016 PyThreadState* __tstate = wxPyBeginAllowThreads();
8017 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8018 wxPyEndAllowThreads(__tstate);
8019 if (PyErr_Occurred()) SWIG_fail;
8020 }
8021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8022 return resultobj;
8023 fail:
8024 return NULL;
8025 }
8026
8027
8028 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8029 PyObject *resultobj = 0;
8030 wxPoint *arg1 = 0 ;
8031 wxPoint2D *result = 0 ;
8032 wxPoint temp1 ;
8033 PyObject * obj0 = 0 ;
8034 char * kwnames[] = {
8035 (char *) "pt", NULL
8036 };
8037
8038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8039 {
8040 arg1 = &temp1;
8041 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8042 }
8043 {
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8046 wxPyEndAllowThreads(__tstate);
8047 if (PyErr_Occurred()) SWIG_fail;
8048 }
8049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8050 return resultobj;
8051 fail:
8052 return NULL;
8053 }
8054
8055
8056 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8057 PyObject *resultobj = 0;
8058 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8059 int *arg2 = (int *) 0 ;
8060 int *arg3 = (int *) 0 ;
8061 void *argp1 = 0 ;
8062 int res1 = 0 ;
8063 int temp2 ;
8064 int res2 = SWIG_TMPOBJ ;
8065 int temp3 ;
8066 int res3 = SWIG_TMPOBJ ;
8067 PyObject *swig_obj[1] ;
8068
8069 arg2 = &temp2;
8070 arg3 = &temp3;
8071 if (!args) SWIG_fail;
8072 swig_obj[0] = args;
8073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8074 if (!SWIG_IsOK(res1)) {
8075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8076 }
8077 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8078 {
8079 PyThreadState* __tstate = wxPyBeginAllowThreads();
8080 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8081 wxPyEndAllowThreads(__tstate);
8082 if (PyErr_Occurred()) SWIG_fail;
8083 }
8084 resultobj = SWIG_Py_Void();
8085 if (SWIG_IsTmpObj(res2)) {
8086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8087 } else {
8088 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8090 }
8091 if (SWIG_IsTmpObj(res3)) {
8092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8093 } else {
8094 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8096 }
8097 return resultobj;
8098 fail:
8099 return NULL;
8100 }
8101
8102
8103 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8104 PyObject *resultobj = 0;
8105 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8106 int *arg2 = (int *) 0 ;
8107 int *arg3 = (int *) 0 ;
8108 void *argp1 = 0 ;
8109 int res1 = 0 ;
8110 int temp2 ;
8111 int res2 = SWIG_TMPOBJ ;
8112 int temp3 ;
8113 int res3 = SWIG_TMPOBJ ;
8114 PyObject *swig_obj[1] ;
8115
8116 arg2 = &temp2;
8117 arg3 = &temp3;
8118 if (!args) SWIG_fail;
8119 swig_obj[0] = args;
8120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8121 if (!SWIG_IsOK(res1)) {
8122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8123 }
8124 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8125 {
8126 PyThreadState* __tstate = wxPyBeginAllowThreads();
8127 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 resultobj = SWIG_Py_Void();
8132 if (SWIG_IsTmpObj(res2)) {
8133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8134 } else {
8135 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8137 }
8138 if (SWIG_IsTmpObj(res3)) {
8139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8140 } else {
8141 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8143 }
8144 return resultobj;
8145 fail:
8146 return NULL;
8147 }
8148
8149
8150 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8151 PyObject *resultobj = 0;
8152 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8153 double result;
8154 void *argp1 = 0 ;
8155 int res1 = 0 ;
8156 PyObject *swig_obj[1] ;
8157
8158 if (!args) SWIG_fail;
8159 swig_obj[0] = args;
8160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8161 if (!SWIG_IsOK(res1)) {
8162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8163 }
8164 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8165 {
8166 PyThreadState* __tstate = wxPyBeginAllowThreads();
8167 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8168 wxPyEndAllowThreads(__tstate);
8169 if (PyErr_Occurred()) SWIG_fail;
8170 }
8171 resultobj = SWIG_From_double(static_cast< double >(result));
8172 return resultobj;
8173 fail:
8174 return NULL;
8175 }
8176
8177
8178 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8179 PyObject *resultobj = 0;
8180 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8181 double result;
8182 void *argp1 = 0 ;
8183 int res1 = 0 ;
8184 PyObject *swig_obj[1] ;
8185
8186 if (!args) SWIG_fail;
8187 swig_obj[0] = args;
8188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8189 if (!SWIG_IsOK(res1)) {
8190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8191 }
8192 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8193 {
8194 PyThreadState* __tstate = wxPyBeginAllowThreads();
8195 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8196 wxPyEndAllowThreads(__tstate);
8197 if (PyErr_Occurred()) SWIG_fail;
8198 }
8199 resultobj = SWIG_From_double(static_cast< double >(result));
8200 return resultobj;
8201 fail:
8202 return NULL;
8203 }
8204
8205
8206 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8207 PyObject *resultobj = 0;
8208 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8209 double arg2 ;
8210 void *argp1 = 0 ;
8211 int res1 = 0 ;
8212 double val2 ;
8213 int ecode2 = 0 ;
8214 PyObject * obj0 = 0 ;
8215 PyObject * obj1 = 0 ;
8216 char * kwnames[] = {
8217 (char *) "self",(char *) "length", NULL
8218 };
8219
8220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8222 if (!SWIG_IsOK(res1)) {
8223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8224 }
8225 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8226 ecode2 = SWIG_AsVal_double(obj1, &val2);
8227 if (!SWIG_IsOK(ecode2)) {
8228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8229 }
8230 arg2 = static_cast< double >(val2);
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 (arg1)->SetVectorLength(arg2);
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 resultobj = SWIG_Py_Void();
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj = 0;
8246 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8247 double arg2 ;
8248 void *argp1 = 0 ;
8249 int res1 = 0 ;
8250 double val2 ;
8251 int ecode2 = 0 ;
8252 PyObject * obj0 = 0 ;
8253 PyObject * obj1 = 0 ;
8254 char * kwnames[] = {
8255 (char *) "self",(char *) "degrees", NULL
8256 };
8257
8258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8260 if (!SWIG_IsOK(res1)) {
8261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8262 }
8263 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8264 ecode2 = SWIG_AsVal_double(obj1, &val2);
8265 if (!SWIG_IsOK(ecode2)) {
8266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8267 }
8268 arg2 = static_cast< double >(val2);
8269 {
8270 PyThreadState* __tstate = wxPyBeginAllowThreads();
8271 (arg1)->SetVectorAngle(arg2);
8272 wxPyEndAllowThreads(__tstate);
8273 if (PyErr_Occurred()) SWIG_fail;
8274 }
8275 resultobj = SWIG_Py_Void();
8276 return resultobj;
8277 fail:
8278 return NULL;
8279 }
8280
8281
8282 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8283 PyObject *resultobj = 0;
8284 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8285 wxPoint2D *arg2 = 0 ;
8286 double result;
8287 void *argp1 = 0 ;
8288 int res1 = 0 ;
8289 wxPoint2D temp2 ;
8290 PyObject * obj0 = 0 ;
8291 PyObject * obj1 = 0 ;
8292 char * kwnames[] = {
8293 (char *) "self",(char *) "pt", NULL
8294 };
8295
8296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8298 if (!SWIG_IsOK(res1)) {
8299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8300 }
8301 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8302 {
8303 arg2 = &temp2;
8304 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8305 }
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8309 wxPyEndAllowThreads(__tstate);
8310 if (PyErr_Occurred()) SWIG_fail;
8311 }
8312 resultobj = SWIG_From_double(static_cast< double >(result));
8313 return resultobj;
8314 fail:
8315 return NULL;
8316 }
8317
8318
8319 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8320 PyObject *resultobj = 0;
8321 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8322 wxPoint2D *arg2 = 0 ;
8323 double result;
8324 void *argp1 = 0 ;
8325 int res1 = 0 ;
8326 wxPoint2D temp2 ;
8327 PyObject * obj0 = 0 ;
8328 PyObject * obj1 = 0 ;
8329 char * kwnames[] = {
8330 (char *) "self",(char *) "pt", NULL
8331 };
8332
8333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8335 if (!SWIG_IsOK(res1)) {
8336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8337 }
8338 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8339 {
8340 arg2 = &temp2;
8341 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8342 }
8343 {
8344 PyThreadState* __tstate = wxPyBeginAllowThreads();
8345 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8346 wxPyEndAllowThreads(__tstate);
8347 if (PyErr_Occurred()) SWIG_fail;
8348 }
8349 resultobj = SWIG_From_double(static_cast< double >(result));
8350 return resultobj;
8351 fail:
8352 return NULL;
8353 }
8354
8355
8356 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8357 PyObject *resultobj = 0;
8358 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8359 wxPoint2D *arg2 = 0 ;
8360 double result;
8361 void *argp1 = 0 ;
8362 int res1 = 0 ;
8363 wxPoint2D temp2 ;
8364 PyObject * obj0 = 0 ;
8365 PyObject * obj1 = 0 ;
8366 char * kwnames[] = {
8367 (char *) "self",(char *) "vec", NULL
8368 };
8369
8370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8372 if (!SWIG_IsOK(res1)) {
8373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8374 }
8375 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8376 {
8377 arg2 = &temp2;
8378 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8379 }
8380 {
8381 PyThreadState* __tstate = wxPyBeginAllowThreads();
8382 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8383 wxPyEndAllowThreads(__tstate);
8384 if (PyErr_Occurred()) SWIG_fail;
8385 }
8386 resultobj = SWIG_From_double(static_cast< double >(result));
8387 return resultobj;
8388 fail:
8389 return NULL;
8390 }
8391
8392
8393 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj = 0;
8395 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8396 wxPoint2D *arg2 = 0 ;
8397 double result;
8398 void *argp1 = 0 ;
8399 int res1 = 0 ;
8400 wxPoint2D temp2 ;
8401 PyObject * obj0 = 0 ;
8402 PyObject * obj1 = 0 ;
8403 char * kwnames[] = {
8404 (char *) "self",(char *) "vec", NULL
8405 };
8406
8407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8409 if (!SWIG_IsOK(res1)) {
8410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8411 }
8412 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8413 {
8414 arg2 = &temp2;
8415 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8416 }
8417 {
8418 PyThreadState* __tstate = wxPyBeginAllowThreads();
8419 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8420 wxPyEndAllowThreads(__tstate);
8421 if (PyErr_Occurred()) SWIG_fail;
8422 }
8423 resultobj = SWIG_From_double(static_cast< double >(result));
8424 return resultobj;
8425 fail:
8426 return NULL;
8427 }
8428
8429
8430 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8431 PyObject *resultobj = 0;
8432 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8433 wxPoint2D result;
8434 void *argp1 = 0 ;
8435 int res1 = 0 ;
8436 PyObject *swig_obj[1] ;
8437
8438 if (!args) SWIG_fail;
8439 swig_obj[0] = args;
8440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8441 if (!SWIG_IsOK(res1)) {
8442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8443 }
8444 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8445 {
8446 PyThreadState* __tstate = wxPyBeginAllowThreads();
8447 result = (arg1)->operator -();
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 wxPoint2D *arg2 = 0 ;
8462 wxPoint2D *result = 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 wxPoint2D temp2 ;
8466 PyObject * obj0 = 0 ;
8467 PyObject * obj1 = 0 ;
8468 char * kwnames[] = {
8469 (char *) "self",(char *) "pt", NULL
8470 };
8471
8472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8474 if (!SWIG_IsOK(res1)) {
8475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8476 }
8477 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8478 {
8479 arg2 = &temp2;
8480 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8481 }
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 {
8485 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8486 result = (wxPoint2D *) &_result_ref;
8487 }
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8492 return resultobj;
8493 fail:
8494 return NULL;
8495 }
8496
8497
8498 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8499 PyObject *resultobj = 0;
8500 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8501 wxPoint2D *arg2 = 0 ;
8502 wxPoint2D *result = 0 ;
8503 void *argp1 = 0 ;
8504 int res1 = 0 ;
8505 wxPoint2D temp2 ;
8506 PyObject * obj0 = 0 ;
8507 PyObject * obj1 = 0 ;
8508 char * kwnames[] = {
8509 (char *) "self",(char *) "pt", NULL
8510 };
8511
8512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8514 if (!SWIG_IsOK(res1)) {
8515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8516 }
8517 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8518 {
8519 arg2 = &temp2;
8520 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8521 }
8522 {
8523 PyThreadState* __tstate = wxPyBeginAllowThreads();
8524 {
8525 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8526 result = (wxPoint2D *) &_result_ref;
8527 }
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8532 return resultobj;
8533 fail:
8534 return NULL;
8535 }
8536
8537
8538 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj = 0;
8540 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8541 wxPoint2D *arg2 = 0 ;
8542 wxPoint2D *result = 0 ;
8543 void *argp1 = 0 ;
8544 int res1 = 0 ;
8545 wxPoint2D temp2 ;
8546 PyObject * obj0 = 0 ;
8547 PyObject * obj1 = 0 ;
8548 char * kwnames[] = {
8549 (char *) "self",(char *) "pt", NULL
8550 };
8551
8552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8554 if (!SWIG_IsOK(res1)) {
8555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8556 }
8557 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8558 {
8559 arg2 = &temp2;
8560 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8561 }
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 {
8565 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8566 result = (wxPoint2D *) &_result_ref;
8567 }
8568 wxPyEndAllowThreads(__tstate);
8569 if (PyErr_Occurred()) SWIG_fail;
8570 }
8571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj = 0;
8580 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8581 wxPoint2D *arg2 = 0 ;
8582 wxPoint2D *result = 0 ;
8583 void *argp1 = 0 ;
8584 int res1 = 0 ;
8585 wxPoint2D temp2 ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 char * kwnames[] = {
8589 (char *) "self",(char *) "pt", NULL
8590 };
8591
8592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8594 if (!SWIG_IsOK(res1)) {
8595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8596 }
8597 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8598 {
8599 arg2 = &temp2;
8600 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8601 }
8602 {
8603 PyThreadState* __tstate = wxPyBeginAllowThreads();
8604 {
8605 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8606 result = (wxPoint2D *) &_result_ref;
8607 }
8608 wxPyEndAllowThreads(__tstate);
8609 if (PyErr_Occurred()) SWIG_fail;
8610 }
8611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8612 return resultobj;
8613 fail:
8614 return NULL;
8615 }
8616
8617
8618 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8619 PyObject *resultobj = 0;
8620 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8621 PyObject *arg2 = (PyObject *) 0 ;
8622 bool result;
8623 void *argp1 = 0 ;
8624 int res1 = 0 ;
8625 PyObject * obj0 = 0 ;
8626 PyObject * obj1 = 0 ;
8627 char * kwnames[] = {
8628 (char *) "self",(char *) "other", NULL
8629 };
8630
8631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8633 if (!SWIG_IsOK(res1)) {
8634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8635 }
8636 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8637 arg2 = obj1;
8638 {
8639 result = (bool)wxPoint2D___eq__(arg1,arg2);
8640 if (PyErr_Occurred()) SWIG_fail;
8641 }
8642 {
8643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8644 }
8645 return resultobj;
8646 fail:
8647 return NULL;
8648 }
8649
8650
8651 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj = 0;
8653 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8654 PyObject *arg2 = (PyObject *) 0 ;
8655 bool result;
8656 void *argp1 = 0 ;
8657 int res1 = 0 ;
8658 PyObject * obj0 = 0 ;
8659 PyObject * obj1 = 0 ;
8660 char * kwnames[] = {
8661 (char *) "self",(char *) "other", NULL
8662 };
8663
8664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8666 if (!SWIG_IsOK(res1)) {
8667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8668 }
8669 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8670 arg2 = obj1;
8671 {
8672 result = (bool)wxPoint2D___ne__(arg1,arg2);
8673 if (PyErr_Occurred()) SWIG_fail;
8674 }
8675 {
8676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8677 }
8678 return resultobj;
8679 fail:
8680 return NULL;
8681 }
8682
8683
8684 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8685 PyObject *resultobj = 0;
8686 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8687 double arg2 ;
8688 void *argp1 = 0 ;
8689 int res1 = 0 ;
8690 double val2 ;
8691 int ecode2 = 0 ;
8692 PyObject *swig_obj[2] ;
8693
8694 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8696 if (!SWIG_IsOK(res1)) {
8697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8698 }
8699 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8700 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8701 if (!SWIG_IsOK(ecode2)) {
8702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8703 }
8704 arg2 = static_cast< double >(val2);
8705 if (arg1) (arg1)->m_x = arg2;
8706
8707 resultobj = SWIG_Py_Void();
8708 return resultobj;
8709 fail:
8710 return NULL;
8711 }
8712
8713
8714 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8715 PyObject *resultobj = 0;
8716 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8717 double result;
8718 void *argp1 = 0 ;
8719 int res1 = 0 ;
8720 PyObject *swig_obj[1] ;
8721
8722 if (!args) SWIG_fail;
8723 swig_obj[0] = args;
8724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8725 if (!SWIG_IsOK(res1)) {
8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8727 }
8728 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8729 result = (double) ((arg1)->m_x);
8730 resultobj = SWIG_From_double(static_cast< double >(result));
8731 return resultobj;
8732 fail:
8733 return NULL;
8734 }
8735
8736
8737 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8738 PyObject *resultobj = 0;
8739 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8740 double arg2 ;
8741 void *argp1 = 0 ;
8742 int res1 = 0 ;
8743 double val2 ;
8744 int ecode2 = 0 ;
8745 PyObject *swig_obj[2] ;
8746
8747 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8749 if (!SWIG_IsOK(res1)) {
8750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8751 }
8752 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8753 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8754 if (!SWIG_IsOK(ecode2)) {
8755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8756 }
8757 arg2 = static_cast< double >(val2);
8758 if (arg1) (arg1)->m_y = arg2;
8759
8760 resultobj = SWIG_Py_Void();
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 double result;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 PyObject *swig_obj[1] ;
8774
8775 if (!args) SWIG_fail;
8776 swig_obj[0] = args;
8777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8778 if (!SWIG_IsOK(res1)) {
8779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8780 }
8781 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8782 result = (double) ((arg1)->m_y);
8783 resultobj = SWIG_From_double(static_cast< double >(result));
8784 return resultobj;
8785 fail:
8786 return NULL;
8787 }
8788
8789
8790 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8791 PyObject *resultobj = 0;
8792 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8793 double arg2 = (double) 0 ;
8794 double arg3 = (double) 0 ;
8795 void *argp1 = 0 ;
8796 int res1 = 0 ;
8797 double val2 ;
8798 int ecode2 = 0 ;
8799 double val3 ;
8800 int ecode3 = 0 ;
8801 PyObject * obj0 = 0 ;
8802 PyObject * obj1 = 0 ;
8803 PyObject * obj2 = 0 ;
8804 char * kwnames[] = {
8805 (char *) "self",(char *) "x",(char *) "y", NULL
8806 };
8807
8808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8810 if (!SWIG_IsOK(res1)) {
8811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8812 }
8813 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8814 if (obj1) {
8815 ecode2 = SWIG_AsVal_double(obj1, &val2);
8816 if (!SWIG_IsOK(ecode2)) {
8817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8818 }
8819 arg2 = static_cast< double >(val2);
8820 }
8821 if (obj2) {
8822 ecode3 = SWIG_AsVal_double(obj2, &val3);
8823 if (!SWIG_IsOK(ecode3)) {
8824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8825 }
8826 arg3 = static_cast< double >(val3);
8827 }
8828 {
8829 PyThreadState* __tstate = wxPyBeginAllowThreads();
8830 wxPoint2D_Set(arg1,arg2,arg3);
8831 wxPyEndAllowThreads(__tstate);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 resultobj = SWIG_Py_Void();
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8842 PyObject *resultobj = 0;
8843 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8844 PyObject *result = 0 ;
8845 void *argp1 = 0 ;
8846 int res1 = 0 ;
8847 PyObject *swig_obj[1] ;
8848
8849 if (!args) SWIG_fail;
8850 swig_obj[0] = args;
8851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8854 }
8855 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 result = (PyObject *)wxPoint2D_Get(arg1);
8859 wxPyEndAllowThreads(__tstate);
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = result;
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8870 PyObject *obj;
8871 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8872 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8873 return SWIG_Py_Void();
8874 }
8875
8876 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8877 return SWIG_Python_InitShadowInstance(args);
8878 }
8879
8880 SWIGINTERN int DefaultPosition_set(PyObject *) {
8881 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8882 return 1;
8883 }
8884
8885
8886 SWIGINTERN PyObject *DefaultPosition_get(void) {
8887 PyObject *pyobj = 0;
8888
8889 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8890 return pyobj;
8891 }
8892
8893
8894 SWIGINTERN int DefaultSize_set(PyObject *) {
8895 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8896 return 1;
8897 }
8898
8899
8900 SWIGINTERN PyObject *DefaultSize_get(void) {
8901 PyObject *pyobj = 0;
8902
8903 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8904 return pyobj;
8905 }
8906
8907
8908 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8909 PyObject *resultobj = 0;
8910 PyObject *arg1 = (PyObject *) 0 ;
8911 wxPyInputStream *result = 0 ;
8912 PyObject * obj0 = 0 ;
8913 char * kwnames[] = {
8914 (char *) "p", NULL
8915 };
8916
8917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8918 arg1 = obj0;
8919 {
8920 PyThreadState* __tstate = wxPyBeginAllowThreads();
8921 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8922 wxPyEndAllowThreads(__tstate);
8923 if (PyErr_Occurred()) SWIG_fail;
8924 }
8925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8926 return resultobj;
8927 fail:
8928 return NULL;
8929 }
8930
8931
8932 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8933 PyObject *resultobj = 0;
8934 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8935 void *argp1 = 0 ;
8936 int res1 = 0 ;
8937 PyObject *swig_obj[1] ;
8938
8939 if (!args) SWIG_fail;
8940 swig_obj[0] = args;
8941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8942 if (!SWIG_IsOK(res1)) {
8943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8944 }
8945 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 delete arg1;
8949
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 resultobj = SWIG_Py_Void();
8954 return resultobj;
8955 fail:
8956 return NULL;
8957 }
8958
8959
8960 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8961 PyObject *resultobj = 0;
8962 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8963 void *argp1 = 0 ;
8964 int res1 = 0 ;
8965 PyObject *swig_obj[1] ;
8966
8967 if (!args) SWIG_fail;
8968 swig_obj[0] = args;
8969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8970 if (!SWIG_IsOK(res1)) {
8971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8972 }
8973 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 (arg1)->close();
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 resultobj = SWIG_Py_Void();
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8988 PyObject *resultobj = 0;
8989 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 PyObject *swig_obj[1] ;
8993
8994 if (!args) SWIG_fail;
8995 swig_obj[0] = args;
8996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8997 if (!SWIG_IsOK(res1)) {
8998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8999 }
9000 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 (arg1)->flush();
9004 wxPyEndAllowThreads(__tstate);
9005 if (PyErr_Occurred()) SWIG_fail;
9006 }
9007 resultobj = SWIG_Py_Void();
9008 return resultobj;
9009 fail:
9010 return NULL;
9011 }
9012
9013
9014 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9015 PyObject *resultobj = 0;
9016 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9017 bool result;
9018 void *argp1 = 0 ;
9019 int res1 = 0 ;
9020 PyObject *swig_obj[1] ;
9021
9022 if (!args) SWIG_fail;
9023 swig_obj[0] = args;
9024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9025 if (!SWIG_IsOK(res1)) {
9026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9027 }
9028 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9029 {
9030 PyThreadState* __tstate = wxPyBeginAllowThreads();
9031 result = (bool)(arg1)->eof();
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 {
9036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9037 }
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj = 0;
9046 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9047 int arg2 = (int) -1 ;
9048 PyObject *result = 0 ;
9049 void *argp1 = 0 ;
9050 int res1 = 0 ;
9051 int val2 ;
9052 int ecode2 = 0 ;
9053 PyObject * obj0 = 0 ;
9054 PyObject * obj1 = 0 ;
9055 char * kwnames[] = {
9056 (char *) "self",(char *) "size", NULL
9057 };
9058
9059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9061 if (!SWIG_IsOK(res1)) {
9062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9063 }
9064 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9065 if (obj1) {
9066 ecode2 = SWIG_AsVal_int(obj1, &val2);
9067 if (!SWIG_IsOK(ecode2)) {
9068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9069 }
9070 arg2 = static_cast< int >(val2);
9071 }
9072 {
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 result = (PyObject *)(arg1)->read(arg2);
9075 wxPyEndAllowThreads(__tstate);
9076 if (PyErr_Occurred()) SWIG_fail;
9077 }
9078 resultobj = result;
9079 return resultobj;
9080 fail:
9081 return NULL;
9082 }
9083
9084
9085 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9086 PyObject *resultobj = 0;
9087 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9088 int arg2 = (int) -1 ;
9089 PyObject *result = 0 ;
9090 void *argp1 = 0 ;
9091 int res1 = 0 ;
9092 int val2 ;
9093 int ecode2 = 0 ;
9094 PyObject * obj0 = 0 ;
9095 PyObject * obj1 = 0 ;
9096 char * kwnames[] = {
9097 (char *) "self",(char *) "size", NULL
9098 };
9099
9100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9102 if (!SWIG_IsOK(res1)) {
9103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9104 }
9105 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9106 if (obj1) {
9107 ecode2 = SWIG_AsVal_int(obj1, &val2);
9108 if (!SWIG_IsOK(ecode2)) {
9109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9110 }
9111 arg2 = static_cast< int >(val2);
9112 }
9113 {
9114 PyThreadState* __tstate = wxPyBeginAllowThreads();
9115 result = (PyObject *)(arg1)->readline(arg2);
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 resultobj = result;
9120 return resultobj;
9121 fail:
9122 return NULL;
9123 }
9124
9125
9126 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9127 PyObject *resultobj = 0;
9128 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9129 int arg2 = (int) -1 ;
9130 PyObject *result = 0 ;
9131 void *argp1 = 0 ;
9132 int res1 = 0 ;
9133 int val2 ;
9134 int ecode2 = 0 ;
9135 PyObject * obj0 = 0 ;
9136 PyObject * obj1 = 0 ;
9137 char * kwnames[] = {
9138 (char *) "self",(char *) "sizehint", NULL
9139 };
9140
9141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9143 if (!SWIG_IsOK(res1)) {
9144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9145 }
9146 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9147 if (obj1) {
9148 ecode2 = SWIG_AsVal_int(obj1, &val2);
9149 if (!SWIG_IsOK(ecode2)) {
9150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9151 }
9152 arg2 = static_cast< int >(val2);
9153 }
9154 {
9155 PyThreadState* __tstate = wxPyBeginAllowThreads();
9156 result = (PyObject *)(arg1)->readlines(arg2);
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 resultobj = result;
9161 return resultobj;
9162 fail:
9163 return NULL;
9164 }
9165
9166
9167 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9168 PyObject *resultobj = 0;
9169 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9170 int arg2 ;
9171 int arg3 = (int) 0 ;
9172 void *argp1 = 0 ;
9173 int res1 = 0 ;
9174 int val2 ;
9175 int ecode2 = 0 ;
9176 int val3 ;
9177 int ecode3 = 0 ;
9178 PyObject * obj0 = 0 ;
9179 PyObject * obj1 = 0 ;
9180 PyObject * obj2 = 0 ;
9181 char * kwnames[] = {
9182 (char *) "self",(char *) "offset",(char *) "whence", NULL
9183 };
9184
9185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9187 if (!SWIG_IsOK(res1)) {
9188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9189 }
9190 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9191 ecode2 = SWIG_AsVal_int(obj1, &val2);
9192 if (!SWIG_IsOK(ecode2)) {
9193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9194 }
9195 arg2 = static_cast< int >(val2);
9196 if (obj2) {
9197 ecode3 = SWIG_AsVal_int(obj2, &val3);
9198 if (!SWIG_IsOK(ecode3)) {
9199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9200 }
9201 arg3 = static_cast< int >(val3);
9202 }
9203 {
9204 PyThreadState* __tstate = wxPyBeginAllowThreads();
9205 (arg1)->seek(arg2,arg3);
9206 wxPyEndAllowThreads(__tstate);
9207 if (PyErr_Occurred()) SWIG_fail;
9208 }
9209 resultobj = SWIG_Py_Void();
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9217 PyObject *resultobj = 0;
9218 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9219 int result;
9220 void *argp1 = 0 ;
9221 int res1 = 0 ;
9222 PyObject *swig_obj[1] ;
9223
9224 if (!args) SWIG_fail;
9225 swig_obj[0] = args;
9226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9227 if (!SWIG_IsOK(res1)) {
9228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9229 }
9230 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9231 {
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 result = (int)(arg1)->tell();
9234 wxPyEndAllowThreads(__tstate);
9235 if (PyErr_Occurred()) SWIG_fail;
9236 }
9237 resultobj = SWIG_From_int(static_cast< int >(result));
9238 return resultobj;
9239 fail:
9240 return NULL;
9241 }
9242
9243
9244 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9245 PyObject *resultobj = 0;
9246 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9247 char result;
9248 void *argp1 = 0 ;
9249 int res1 = 0 ;
9250 PyObject *swig_obj[1] ;
9251
9252 if (!args) SWIG_fail;
9253 swig_obj[0] = args;
9254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9255 if (!SWIG_IsOK(res1)) {
9256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9257 }
9258 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9259 {
9260 PyThreadState* __tstate = wxPyBeginAllowThreads();
9261 result = (char)(arg1)->Peek();
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 resultobj = SWIG_From_char(static_cast< char >(result));
9266 return resultobj;
9267 fail:
9268 return NULL;
9269 }
9270
9271
9272 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9273 PyObject *resultobj = 0;
9274 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9275 char result;
9276 void *argp1 = 0 ;
9277 int res1 = 0 ;
9278 PyObject *swig_obj[1] ;
9279
9280 if (!args) SWIG_fail;
9281 swig_obj[0] = args;
9282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9283 if (!SWIG_IsOK(res1)) {
9284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9285 }
9286 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9287 {
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 result = (char)(arg1)->GetC();
9290 wxPyEndAllowThreads(__tstate);
9291 if (PyErr_Occurred()) SWIG_fail;
9292 }
9293 resultobj = SWIG_From_char(static_cast< char >(result));
9294 return resultobj;
9295 fail:
9296 return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301 PyObject *resultobj = 0;
9302 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9303 size_t result;
9304 void *argp1 = 0 ;
9305 int res1 = 0 ;
9306 PyObject *swig_obj[1] ;
9307
9308 if (!args) SWIG_fail;
9309 swig_obj[0] = args;
9310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9311 if (!SWIG_IsOK(res1)) {
9312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9313 }
9314 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9315 {
9316 PyThreadState* __tstate = wxPyBeginAllowThreads();
9317 result = (size_t)(arg1)->LastRead();
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9329 PyObject *resultobj = 0;
9330 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9331 bool result;
9332 void *argp1 = 0 ;
9333 int res1 = 0 ;
9334 PyObject *swig_obj[1] ;
9335
9336 if (!args) SWIG_fail;
9337 swig_obj[0] = args;
9338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9339 if (!SWIG_IsOK(res1)) {
9340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9341 }
9342 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 result = (bool)(arg1)->CanRead();
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 {
9350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9351 }
9352 return resultobj;
9353 fail:
9354 return NULL;
9355 }
9356
9357
9358 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9359 PyObject *resultobj = 0;
9360 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9361 bool result;
9362 void *argp1 = 0 ;
9363 int res1 = 0 ;
9364 PyObject *swig_obj[1] ;
9365
9366 if (!args) SWIG_fail;
9367 swig_obj[0] = args;
9368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9369 if (!SWIG_IsOK(res1)) {
9370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9371 }
9372 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9373 {
9374 PyThreadState* __tstate = wxPyBeginAllowThreads();
9375 result = (bool)(arg1)->Eof();
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 {
9380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9381 }
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9389 PyObject *resultobj = 0;
9390 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9391 char arg2 ;
9392 bool result;
9393 void *argp1 = 0 ;
9394 int res1 = 0 ;
9395 char val2 ;
9396 int ecode2 = 0 ;
9397 PyObject * obj0 = 0 ;
9398 PyObject * obj1 = 0 ;
9399 char * kwnames[] = {
9400 (char *) "self",(char *) "c", NULL
9401 };
9402
9403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9405 if (!SWIG_IsOK(res1)) {
9406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9407 }
9408 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9409 ecode2 = SWIG_AsVal_char(obj1, &val2);
9410 if (!SWIG_IsOK(ecode2)) {
9411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9412 }
9413 arg2 = static_cast< char >(val2);
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = (bool)(arg1)->Ungetch(arg2);
9417 wxPyEndAllowThreads(__tstate);
9418 if (PyErr_Occurred()) SWIG_fail;
9419 }
9420 {
9421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9422 }
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj = 0;
9431 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9432 long arg2 ;
9433 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9434 long result;
9435 void *argp1 = 0 ;
9436 int res1 = 0 ;
9437 long val2 ;
9438 int ecode2 = 0 ;
9439 int val3 ;
9440 int ecode3 = 0 ;
9441 PyObject * obj0 = 0 ;
9442 PyObject * obj1 = 0 ;
9443 PyObject * obj2 = 0 ;
9444 char * kwnames[] = {
9445 (char *) "self",(char *) "pos",(char *) "mode", NULL
9446 };
9447
9448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9450 if (!SWIG_IsOK(res1)) {
9451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9452 }
9453 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9454 ecode2 = SWIG_AsVal_long(obj1, &val2);
9455 if (!SWIG_IsOK(ecode2)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9457 }
9458 arg2 = static_cast< long >(val2);
9459 if (obj2) {
9460 ecode3 = SWIG_AsVal_int(obj2, &val3);
9461 if (!SWIG_IsOK(ecode3)) {
9462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9463 }
9464 arg3 = static_cast< wxSeekMode >(val3);
9465 }
9466 {
9467 PyThreadState* __tstate = wxPyBeginAllowThreads();
9468 result = (long)(arg1)->SeekI(arg2,arg3);
9469 wxPyEndAllowThreads(__tstate);
9470 if (PyErr_Occurred()) SWIG_fail;
9471 }
9472 resultobj = SWIG_From_long(static_cast< long >(result));
9473 return resultobj;
9474 fail:
9475 return NULL;
9476 }
9477
9478
9479 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9480 PyObject *resultobj = 0;
9481 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9482 long result;
9483 void *argp1 = 0 ;
9484 int res1 = 0 ;
9485 PyObject *swig_obj[1] ;
9486
9487 if (!args) SWIG_fail;
9488 swig_obj[0] = args;
9489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9490 if (!SWIG_IsOK(res1)) {
9491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9492 }
9493 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9494 {
9495 PyThreadState* __tstate = wxPyBeginAllowThreads();
9496 result = (long)(arg1)->TellI();
9497 wxPyEndAllowThreads(__tstate);
9498 if (PyErr_Occurred()) SWIG_fail;
9499 }
9500 resultobj = SWIG_From_long(static_cast< long >(result));
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9508 PyObject *obj;
9509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9510 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9511 return SWIG_Py_Void();
9512 }
9513
9514 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9515 return SWIG_Python_InitShadowInstance(args);
9516 }
9517
9518 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9519 PyObject *resultobj = 0;
9520 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9521 PyObject *arg2 = (PyObject *) 0 ;
9522 void *argp1 = 0 ;
9523 int res1 = 0 ;
9524 PyObject * obj0 = 0 ;
9525 PyObject * obj1 = 0 ;
9526 char * kwnames[] = {
9527 (char *) "self",(char *) "obj", NULL
9528 };
9529
9530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9534 }
9535 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9536 arg2 = obj1;
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 wxOutputStream_write(arg1,arg2);
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_Py_Void();
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9551 PyObject *resultobj = 0;
9552 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9553 size_t result;
9554 void *argp1 = 0 ;
9555 int res1 = 0 ;
9556 PyObject *swig_obj[1] ;
9557
9558 if (!args) SWIG_fail;
9559 swig_obj[0] = args;
9560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9561 if (!SWIG_IsOK(res1)) {
9562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9563 }
9564 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9565 {
9566 PyThreadState* __tstate = wxPyBeginAllowThreads();
9567 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9568 wxPyEndAllowThreads(__tstate);
9569 if (PyErr_Occurred()) SWIG_fail;
9570 }
9571 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9572 return resultobj;
9573 fail:
9574 return NULL;
9575 }
9576
9577
9578 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9579 PyObject *obj;
9580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9581 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9582 return SWIG_Py_Void();
9583 }
9584
9585 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9586 PyObject *resultobj = 0;
9587 wxInputStream *arg1 = (wxInputStream *) 0 ;
9588 wxString *arg2 = 0 ;
9589 wxString *arg3 = 0 ;
9590 wxString *arg4 = 0 ;
9591 wxDateTime arg5 ;
9592 wxFSFile *result = 0 ;
9593 wxPyInputStream *temp1 ;
9594 bool temp2 = false ;
9595 bool temp3 = false ;
9596 bool temp4 = false ;
9597 void *argp5 ;
9598 int res5 = 0 ;
9599 PyObject * obj0 = 0 ;
9600 PyObject * obj1 = 0 ;
9601 PyObject * obj2 = 0 ;
9602 PyObject * obj3 = 0 ;
9603 PyObject * obj4 = 0 ;
9604 char * kwnames[] = {
9605 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9606 };
9607
9608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9609 {
9610 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9611 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9612 } else {
9613 PyErr_Clear(); // clear the failure of the wxPyConvert above
9614 arg1 = wxPyCBInputStream_create(obj0, true);
9615 if (arg1 == NULL) {
9616 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9617 SWIG_fail;
9618 }
9619 }
9620 }
9621 {
9622 arg2 = wxString_in_helper(obj1);
9623 if (arg2 == NULL) SWIG_fail;
9624 temp2 = true;
9625 }
9626 {
9627 arg3 = wxString_in_helper(obj2);
9628 if (arg3 == NULL) SWIG_fail;
9629 temp3 = true;
9630 }
9631 {
9632 arg4 = wxString_in_helper(obj3);
9633 if (arg4 == NULL) SWIG_fail;
9634 temp4 = true;
9635 }
9636 {
9637 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9638 if (!SWIG_IsOK(res5)) {
9639 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9640 }
9641 if (!argp5) {
9642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9643 } else {
9644 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9645 arg5 = *temp;
9646 if (SWIG_IsNewObj(res5)) delete temp;
9647 }
9648 }
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9652 wxPyEndAllowThreads(__tstate);
9653 if (PyErr_Occurred()) SWIG_fail;
9654 }
9655 {
9656 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9657 }
9658 {
9659 if (temp2)
9660 delete arg2;
9661 }
9662 {
9663 if (temp3)
9664 delete arg3;
9665 }
9666 {
9667 if (temp4)
9668 delete arg4;
9669 }
9670 return resultobj;
9671 fail:
9672 {
9673 if (temp2)
9674 delete arg2;
9675 }
9676 {
9677 if (temp3)
9678 delete arg3;
9679 }
9680 {
9681 if (temp4)
9682 delete arg4;
9683 }
9684 return NULL;
9685 }
9686
9687
9688 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9689 PyObject *resultobj = 0;
9690 wxFSFile *arg1 = (wxFSFile *) 0 ;
9691 void *argp1 = 0 ;
9692 int res1 = 0 ;
9693 PyObject *swig_obj[1] ;
9694
9695 if (!args) SWIG_fail;
9696 swig_obj[0] = args;
9697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9698 if (!SWIG_IsOK(res1)) {
9699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9700 }
9701 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9702 {
9703 PyThreadState* __tstate = wxPyBeginAllowThreads();
9704 delete arg1;
9705
9706 wxPyEndAllowThreads(__tstate);
9707 if (PyErr_Occurred()) SWIG_fail;
9708 }
9709 resultobj = SWIG_Py_Void();
9710 return resultobj;
9711 fail:
9712 return NULL;
9713 }
9714
9715
9716 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9717 PyObject *resultobj = 0;
9718 wxFSFile *arg1 = (wxFSFile *) 0 ;
9719 wxInputStream *result = 0 ;
9720 void *argp1 = 0 ;
9721 int res1 = 0 ;
9722 PyObject *swig_obj[1] ;
9723
9724 if (!args) SWIG_fail;
9725 swig_obj[0] = args;
9726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9727 if (!SWIG_IsOK(res1)) {
9728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9729 }
9730 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 result = (wxInputStream *)(arg1)->GetStream();
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 {
9738 wxPyInputStream * _ptr = NULL;
9739
9740 if (result) {
9741 _ptr = new wxPyInputStream(result);
9742 }
9743 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9744 }
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9752 PyObject *resultobj = 0;
9753 wxFSFile *arg1 = (wxFSFile *) 0 ;
9754 wxString *result = 0 ;
9755 void *argp1 = 0 ;
9756 int res1 = 0 ;
9757 PyObject *swig_obj[1] ;
9758
9759 if (!args) SWIG_fail;
9760 swig_obj[0] = args;
9761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9762 if (!SWIG_IsOK(res1)) {
9763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9764 }
9765 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 {
9769 wxString const &_result_ref = (arg1)->GetMimeType();
9770 result = (wxString *) &_result_ref;
9771 }
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 #if wxUSE_UNICODE
9777 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9778 #else
9779 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9780 #endif
9781 }
9782 return resultobj;
9783 fail:
9784 return NULL;
9785 }
9786
9787
9788 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9789 PyObject *resultobj = 0;
9790 wxFSFile *arg1 = (wxFSFile *) 0 ;
9791 wxString *result = 0 ;
9792 void *argp1 = 0 ;
9793 int res1 = 0 ;
9794 PyObject *swig_obj[1] ;
9795
9796 if (!args) SWIG_fail;
9797 swig_obj[0] = args;
9798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9799 if (!SWIG_IsOK(res1)) {
9800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9801 }
9802 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 {
9806 wxString const &_result_ref = (arg1)->GetLocation();
9807 result = (wxString *) &_result_ref;
9808 }
9809 wxPyEndAllowThreads(__tstate);
9810 if (PyErr_Occurred()) SWIG_fail;
9811 }
9812 {
9813 #if wxUSE_UNICODE
9814 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9815 #else
9816 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9817 #endif
9818 }
9819 return resultobj;
9820 fail:
9821 return NULL;
9822 }
9823
9824
9825 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9826 PyObject *resultobj = 0;
9827 wxFSFile *arg1 = (wxFSFile *) 0 ;
9828 wxString *result = 0 ;
9829 void *argp1 = 0 ;
9830 int res1 = 0 ;
9831 PyObject *swig_obj[1] ;
9832
9833 if (!args) SWIG_fail;
9834 swig_obj[0] = args;
9835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9836 if (!SWIG_IsOK(res1)) {
9837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9838 }
9839 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9840 {
9841 PyThreadState* __tstate = wxPyBeginAllowThreads();
9842 {
9843 wxString const &_result_ref = (arg1)->GetAnchor();
9844 result = (wxString *) &_result_ref;
9845 }
9846 wxPyEndAllowThreads(__tstate);
9847 if (PyErr_Occurred()) SWIG_fail;
9848 }
9849 {
9850 #if wxUSE_UNICODE
9851 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9852 #else
9853 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9854 #endif
9855 }
9856 return resultobj;
9857 fail:
9858 return NULL;
9859 }
9860
9861
9862 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9863 PyObject *resultobj = 0;
9864 wxFSFile *arg1 = (wxFSFile *) 0 ;
9865 wxDateTime result;
9866 void *argp1 = 0 ;
9867 int res1 = 0 ;
9868 PyObject *swig_obj[1] ;
9869
9870 if (!args) SWIG_fail;
9871 swig_obj[0] = args;
9872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9873 if (!SWIG_IsOK(res1)) {
9874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9875 }
9876 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9877 {
9878 PyThreadState* __tstate = wxPyBeginAllowThreads();
9879 result = (arg1)->GetModificationTime();
9880 wxPyEndAllowThreads(__tstate);
9881 if (PyErr_Occurred()) SWIG_fail;
9882 }
9883 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9891 PyObject *obj;
9892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9893 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9894 return SWIG_Py_Void();
9895 }
9896
9897 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9898 return SWIG_Python_InitShadowInstance(args);
9899 }
9900
9901 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 PyObject *resultobj = 0;
9903 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9904 void *argp1 = 0 ;
9905 int res1 = 0 ;
9906 PyObject *swig_obj[1] ;
9907
9908 if (!args) SWIG_fail;
9909 swig_obj[0] = args;
9910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9911 if (!SWIG_IsOK(res1)) {
9912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9913 }
9914 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9915 {
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 delete arg1;
9918
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 resultobj = SWIG_Py_Void();
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9930 PyObject *obj;
9931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9932 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9933 return SWIG_Py_Void();
9934 }
9935
9936 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9937 PyObject *resultobj = 0;
9938 wxPyFileSystemHandler *result = 0 ;
9939
9940 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9948 return resultobj;
9949 fail:
9950 return NULL;
9951 }
9952
9953
9954 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9955 PyObject *resultobj = 0;
9956 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9957 PyObject *arg2 = (PyObject *) 0 ;
9958 PyObject *arg3 = (PyObject *) 0 ;
9959 void *argp1 = 0 ;
9960 int res1 = 0 ;
9961 PyObject * obj0 = 0 ;
9962 PyObject * obj1 = 0 ;
9963 PyObject * obj2 = 0 ;
9964 char * kwnames[] = {
9965 (char *) "self",(char *) "self",(char *) "_class", NULL
9966 };
9967
9968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9970 if (!SWIG_IsOK(res1)) {
9971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9972 }
9973 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9974 arg2 = obj1;
9975 arg3 = obj2;
9976 {
9977 PyThreadState* __tstate = wxPyBeginAllowThreads();
9978 (arg1)->_setCallbackInfo(arg2,arg3);
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 resultobj = SWIG_Py_Void();
9983 return resultobj;
9984 fail:
9985 return NULL;
9986 }
9987
9988
9989 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9990 PyObject *resultobj = 0;
9991 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9992 wxString *arg2 = 0 ;
9993 bool result;
9994 void *argp1 = 0 ;
9995 int res1 = 0 ;
9996 bool temp2 = false ;
9997 PyObject * obj0 = 0 ;
9998 PyObject * obj1 = 0 ;
9999 char * kwnames[] = {
10000 (char *) "self",(char *) "location", NULL
10001 };
10002
10003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10005 if (!SWIG_IsOK(res1)) {
10006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10007 }
10008 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10009 {
10010 arg2 = wxString_in_helper(obj1);
10011 if (arg2 == NULL) SWIG_fail;
10012 temp2 = true;
10013 }
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 {
10021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10022 }
10023 {
10024 if (temp2)
10025 delete arg2;
10026 }
10027 return resultobj;
10028 fail:
10029 {
10030 if (temp2)
10031 delete arg2;
10032 }
10033 return NULL;
10034 }
10035
10036
10037 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj = 0;
10039 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10040 wxFileSystem *arg2 = 0 ;
10041 wxString *arg3 = 0 ;
10042 wxFSFile *result = 0 ;
10043 void *argp1 = 0 ;
10044 int res1 = 0 ;
10045 void *argp2 = 0 ;
10046 int res2 = 0 ;
10047 bool temp3 = false ;
10048 PyObject * obj0 = 0 ;
10049 PyObject * obj1 = 0 ;
10050 PyObject * obj2 = 0 ;
10051 char * kwnames[] = {
10052 (char *) "self",(char *) "fs",(char *) "location", NULL
10053 };
10054
10055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10057 if (!SWIG_IsOK(res1)) {
10058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10059 }
10060 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10062 if (!SWIG_IsOK(res2)) {
10063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10064 }
10065 if (!argp2) {
10066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10067 }
10068 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10069 {
10070 arg3 = wxString_in_helper(obj2);
10071 if (arg3 == NULL) SWIG_fail;
10072 temp3 = true;
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 {
10081 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10082 }
10083 {
10084 if (temp3)
10085 delete arg3;
10086 }
10087 return resultobj;
10088 fail:
10089 {
10090 if (temp3)
10091 delete arg3;
10092 }
10093 return NULL;
10094 }
10095
10096
10097 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10098 PyObject *resultobj = 0;
10099 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10100 wxString *arg2 = 0 ;
10101 int arg3 = (int) 0 ;
10102 wxString result;
10103 void *argp1 = 0 ;
10104 int res1 = 0 ;
10105 bool temp2 = false ;
10106 int val3 ;
10107 int ecode3 = 0 ;
10108 PyObject * obj0 = 0 ;
10109 PyObject * obj1 = 0 ;
10110 PyObject * obj2 = 0 ;
10111 char * kwnames[] = {
10112 (char *) "self",(char *) "spec",(char *) "flags", NULL
10113 };
10114
10115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10117 if (!SWIG_IsOK(res1)) {
10118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10119 }
10120 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10121 {
10122 arg2 = wxString_in_helper(obj1);
10123 if (arg2 == NULL) SWIG_fail;
10124 temp2 = true;
10125 }
10126 if (obj2) {
10127 ecode3 = SWIG_AsVal_int(obj2, &val3);
10128 if (!SWIG_IsOK(ecode3)) {
10129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10130 }
10131 arg3 = static_cast< int >(val3);
10132 }
10133 {
10134 PyThreadState* __tstate = wxPyBeginAllowThreads();
10135 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10136 wxPyEndAllowThreads(__tstate);
10137 if (PyErr_Occurred()) SWIG_fail;
10138 }
10139 {
10140 #if wxUSE_UNICODE
10141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10142 #else
10143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10144 #endif
10145 }
10146 {
10147 if (temp2)
10148 delete arg2;
10149 }
10150 return resultobj;
10151 fail:
10152 {
10153 if (temp2)
10154 delete arg2;
10155 }
10156 return NULL;
10157 }
10158
10159
10160 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10161 PyObject *resultobj = 0;
10162 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10163 wxString result;
10164 void *argp1 = 0 ;
10165 int res1 = 0 ;
10166 PyObject *swig_obj[1] ;
10167
10168 if (!args) SWIG_fail;
10169 swig_obj[0] = args;
10170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10171 if (!SWIG_IsOK(res1)) {
10172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10173 }
10174 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 result = (arg1)->FindNext();
10178 wxPyEndAllowThreads(__tstate);
10179 if (PyErr_Occurred()) SWIG_fail;
10180 }
10181 {
10182 #if wxUSE_UNICODE
10183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10184 #else
10185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10186 #endif
10187 }
10188 return resultobj;
10189 fail:
10190 return NULL;
10191 }
10192
10193
10194 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10195 PyObject *resultobj = 0;
10196 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10197 wxString *arg2 = 0 ;
10198 wxString result;
10199 void *argp1 = 0 ;
10200 int res1 = 0 ;
10201 bool temp2 = false ;
10202 PyObject * obj0 = 0 ;
10203 PyObject * obj1 = 0 ;
10204 char * kwnames[] = {
10205 (char *) "self",(char *) "location", NULL
10206 };
10207
10208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10210 if (!SWIG_IsOK(res1)) {
10211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10212 }
10213 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10214 {
10215 arg2 = wxString_in_helper(obj1);
10216 if (arg2 == NULL) SWIG_fail;
10217 temp2 = true;
10218 }
10219 {
10220 PyThreadState* __tstate = wxPyBeginAllowThreads();
10221 result = (arg1)->GetProtocol((wxString const &)*arg2);
10222 wxPyEndAllowThreads(__tstate);
10223 if (PyErr_Occurred()) SWIG_fail;
10224 }
10225 {
10226 #if wxUSE_UNICODE
10227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10228 #else
10229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10230 #endif
10231 }
10232 {
10233 if (temp2)
10234 delete arg2;
10235 }
10236 return resultobj;
10237 fail:
10238 {
10239 if (temp2)
10240 delete arg2;
10241 }
10242 return NULL;
10243 }
10244
10245
10246 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10247 PyObject *resultobj = 0;
10248 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10249 wxString *arg2 = 0 ;
10250 wxString result;
10251 void *argp1 = 0 ;
10252 int res1 = 0 ;
10253 bool temp2 = false ;
10254 PyObject * obj0 = 0 ;
10255 PyObject * obj1 = 0 ;
10256 char * kwnames[] = {
10257 (char *) "self",(char *) "location", NULL
10258 };
10259
10260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10262 if (!SWIG_IsOK(res1)) {
10263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10264 }
10265 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10266 {
10267 arg2 = wxString_in_helper(obj1);
10268 if (arg2 == NULL) SWIG_fail;
10269 temp2 = true;
10270 }
10271 {
10272 PyThreadState* __tstate = wxPyBeginAllowThreads();
10273 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10274 wxPyEndAllowThreads(__tstate);
10275 if (PyErr_Occurred()) SWIG_fail;
10276 }
10277 {
10278 #if wxUSE_UNICODE
10279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10280 #else
10281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10282 #endif
10283 }
10284 {
10285 if (temp2)
10286 delete arg2;
10287 }
10288 return resultobj;
10289 fail:
10290 {
10291 if (temp2)
10292 delete arg2;
10293 }
10294 return NULL;
10295 }
10296
10297
10298 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10299 PyObject *resultobj = 0;
10300 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10301 wxString *arg2 = 0 ;
10302 wxString result;
10303 void *argp1 = 0 ;
10304 int res1 = 0 ;
10305 bool temp2 = false ;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 char * kwnames[] = {
10309 (char *) "self",(char *) "location", NULL
10310 };
10311
10312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10314 if (!SWIG_IsOK(res1)) {
10315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10316 }
10317 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10318 {
10319 arg2 = wxString_in_helper(obj1);
10320 if (arg2 == NULL) SWIG_fail;
10321 temp2 = true;
10322 }
10323 {
10324 PyThreadState* __tstate = wxPyBeginAllowThreads();
10325 result = (arg1)->GetAnchor((wxString const &)*arg2);
10326 wxPyEndAllowThreads(__tstate);
10327 if (PyErr_Occurred()) SWIG_fail;
10328 }
10329 {
10330 #if wxUSE_UNICODE
10331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10332 #else
10333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10334 #endif
10335 }
10336 {
10337 if (temp2)
10338 delete arg2;
10339 }
10340 return resultobj;
10341 fail:
10342 {
10343 if (temp2)
10344 delete arg2;
10345 }
10346 return NULL;
10347 }
10348
10349
10350 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj = 0;
10352 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10353 wxString *arg2 = 0 ;
10354 wxString result;
10355 void *argp1 = 0 ;
10356 int res1 = 0 ;
10357 bool temp2 = false ;
10358 PyObject * obj0 = 0 ;
10359 PyObject * obj1 = 0 ;
10360 char * kwnames[] = {
10361 (char *) "self",(char *) "location", NULL
10362 };
10363
10364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10366 if (!SWIG_IsOK(res1)) {
10367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10368 }
10369 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10370 {
10371 arg2 = wxString_in_helper(obj1);
10372 if (arg2 == NULL) SWIG_fail;
10373 temp2 = true;
10374 }
10375 {
10376 PyThreadState* __tstate = wxPyBeginAllowThreads();
10377 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10378 wxPyEndAllowThreads(__tstate);
10379 if (PyErr_Occurred()) SWIG_fail;
10380 }
10381 {
10382 #if wxUSE_UNICODE
10383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10384 #else
10385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10386 #endif
10387 }
10388 {
10389 if (temp2)
10390 delete arg2;
10391 }
10392 return resultobj;
10393 fail:
10394 {
10395 if (temp2)
10396 delete arg2;
10397 }
10398 return NULL;
10399 }
10400
10401
10402 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10403 PyObject *resultobj = 0;
10404 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10405 wxString *arg2 = 0 ;
10406 wxString result;
10407 void *argp1 = 0 ;
10408 int res1 = 0 ;
10409 bool temp2 = false ;
10410 PyObject * obj0 = 0 ;
10411 PyObject * obj1 = 0 ;
10412 char * kwnames[] = {
10413 (char *) "self",(char *) "location", NULL
10414 };
10415
10416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10418 if (!SWIG_IsOK(res1)) {
10419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10420 }
10421 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10422 {
10423 arg2 = wxString_in_helper(obj1);
10424 if (arg2 == NULL) SWIG_fail;
10425 temp2 = true;
10426 }
10427 {
10428 PyThreadState* __tstate = wxPyBeginAllowThreads();
10429 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10430 wxPyEndAllowThreads(__tstate);
10431 if (PyErr_Occurred()) SWIG_fail;
10432 }
10433 {
10434 #if wxUSE_UNICODE
10435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10436 #else
10437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10438 #endif
10439 }
10440 {
10441 if (temp2)
10442 delete arg2;
10443 }
10444 return resultobj;
10445 fail:
10446 {
10447 if (temp2)
10448 delete arg2;
10449 }
10450 return NULL;
10451 }
10452
10453
10454 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10455 PyObject *obj;
10456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10457 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10458 return SWIG_Py_Void();
10459 }
10460
10461 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10462 return SWIG_Python_InitShadowInstance(args);
10463 }
10464
10465 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10466 PyObject *resultobj = 0;
10467 wxFileSystem *result = 0 ;
10468
10469 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10470 {
10471 PyThreadState* __tstate = wxPyBeginAllowThreads();
10472 result = (wxFileSystem *)new wxFileSystem();
10473 wxPyEndAllowThreads(__tstate);
10474 if (PyErr_Occurred()) SWIG_fail;
10475 }
10476 {
10477 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10478 }
10479 return resultobj;
10480 fail:
10481 return NULL;
10482 }
10483
10484
10485 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10486 PyObject *resultobj = 0;
10487 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 PyObject *swig_obj[1] ;
10491
10492 if (!args) SWIG_fail;
10493 swig_obj[0] = args;
10494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10497 }
10498 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 delete arg1;
10502
10503 wxPyEndAllowThreads(__tstate);
10504 if (PyErr_Occurred()) SWIG_fail;
10505 }
10506 resultobj = SWIG_Py_Void();
10507 return resultobj;
10508 fail:
10509 return NULL;
10510 }
10511
10512
10513 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10514 PyObject *resultobj = 0;
10515 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10516 wxString *arg2 = 0 ;
10517 bool arg3 = (bool) false ;
10518 void *argp1 = 0 ;
10519 int res1 = 0 ;
10520 bool temp2 = false ;
10521 bool val3 ;
10522 int ecode3 = 0 ;
10523 PyObject * obj0 = 0 ;
10524 PyObject * obj1 = 0 ;
10525 PyObject * obj2 = 0 ;
10526 char * kwnames[] = {
10527 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10528 };
10529
10530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10534 }
10535 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10536 {
10537 arg2 = wxString_in_helper(obj1);
10538 if (arg2 == NULL) SWIG_fail;
10539 temp2 = true;
10540 }
10541 if (obj2) {
10542 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10543 if (!SWIG_IsOK(ecode3)) {
10544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10545 }
10546 arg3 = static_cast< bool >(val3);
10547 }
10548 {
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 resultobj = SWIG_Py_Void();
10555 {
10556 if (temp2)
10557 delete arg2;
10558 }
10559 return resultobj;
10560 fail:
10561 {
10562 if (temp2)
10563 delete arg2;
10564 }
10565 return NULL;
10566 }
10567
10568
10569 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10570 PyObject *resultobj = 0;
10571 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10572 wxString result;
10573 void *argp1 = 0 ;
10574 int res1 = 0 ;
10575 PyObject *swig_obj[1] ;
10576
10577 if (!args) SWIG_fail;
10578 swig_obj[0] = args;
10579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10580 if (!SWIG_IsOK(res1)) {
10581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10582 }
10583 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (arg1)->GetPath();
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 {
10591 #if wxUSE_UNICODE
10592 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10593 #else
10594 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10595 #endif
10596 }
10597 return resultobj;
10598 fail:
10599 return NULL;
10600 }
10601
10602
10603 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10604 PyObject *resultobj = 0;
10605 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10606 wxString *arg2 = 0 ;
10607 wxFSFile *result = 0 ;
10608 void *argp1 = 0 ;
10609 int res1 = 0 ;
10610 bool temp2 = false ;
10611 PyObject * obj0 = 0 ;
10612 PyObject * obj1 = 0 ;
10613 char * kwnames[] = {
10614 (char *) "self",(char *) "location", NULL
10615 };
10616
10617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10619 if (!SWIG_IsOK(res1)) {
10620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10621 }
10622 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10623 {
10624 arg2 = wxString_in_helper(obj1);
10625 if (arg2 == NULL) SWIG_fail;
10626 temp2 = true;
10627 }
10628 {
10629 PyThreadState* __tstate = wxPyBeginAllowThreads();
10630 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10631 wxPyEndAllowThreads(__tstate);
10632 if (PyErr_Occurred()) SWIG_fail;
10633 }
10634 {
10635 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10636 }
10637 {
10638 if (temp2)
10639 delete arg2;
10640 }
10641 return resultobj;
10642 fail:
10643 {
10644 if (temp2)
10645 delete arg2;
10646 }
10647 return NULL;
10648 }
10649
10650
10651 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10652 PyObject *resultobj = 0;
10653 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10654 wxString *arg2 = 0 ;
10655 int arg3 = (int) 0 ;
10656 wxString result;
10657 void *argp1 = 0 ;
10658 int res1 = 0 ;
10659 bool temp2 = false ;
10660 int val3 ;
10661 int ecode3 = 0 ;
10662 PyObject * obj0 = 0 ;
10663 PyObject * obj1 = 0 ;
10664 PyObject * obj2 = 0 ;
10665 char * kwnames[] = {
10666 (char *) "self",(char *) "spec",(char *) "flags", NULL
10667 };
10668
10669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10671 if (!SWIG_IsOK(res1)) {
10672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10673 }
10674 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10675 {
10676 arg2 = wxString_in_helper(obj1);
10677 if (arg2 == NULL) SWIG_fail;
10678 temp2 = true;
10679 }
10680 if (obj2) {
10681 ecode3 = SWIG_AsVal_int(obj2, &val3);
10682 if (!SWIG_IsOK(ecode3)) {
10683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10684 }
10685 arg3 = static_cast< int >(val3);
10686 }
10687 {
10688 PyThreadState* __tstate = wxPyBeginAllowThreads();
10689 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10690 wxPyEndAllowThreads(__tstate);
10691 if (PyErr_Occurred()) SWIG_fail;
10692 }
10693 {
10694 #if wxUSE_UNICODE
10695 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10696 #else
10697 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10698 #endif
10699 }
10700 {
10701 if (temp2)
10702 delete arg2;
10703 }
10704 return resultobj;
10705 fail:
10706 {
10707 if (temp2)
10708 delete arg2;
10709 }
10710 return NULL;
10711 }
10712
10713
10714 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10715 PyObject *resultobj = 0;
10716 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10717 wxString result;
10718 void *argp1 = 0 ;
10719 int res1 = 0 ;
10720 PyObject *swig_obj[1] ;
10721
10722 if (!args) SWIG_fail;
10723 swig_obj[0] = args;
10724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10725 if (!SWIG_IsOK(res1)) {
10726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10727 }
10728 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 result = (arg1)->FindNext();
10732 wxPyEndAllowThreads(__tstate);
10733 if (PyErr_Occurred()) SWIG_fail;
10734 }
10735 {
10736 #if wxUSE_UNICODE
10737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10738 #else
10739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10740 #endif
10741 }
10742 return resultobj;
10743 fail:
10744 return NULL;
10745 }
10746
10747
10748 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10749 PyObject *resultobj = 0;
10750 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10751 int res1 = 0 ;
10752 PyObject * obj0 = 0 ;
10753 char * kwnames[] = {
10754 (char *) "handler", NULL
10755 };
10756
10757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10758 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10759 if (!SWIG_IsOK(res1)) {
10760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10761 }
10762 {
10763 PyThreadState* __tstate = wxPyBeginAllowThreads();
10764 wxFileSystem::AddHandler(arg1);
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 resultobj = SWIG_Py_Void();
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10776 PyObject *resultobj = 0;
10777
10778 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10779 {
10780 PyThreadState* __tstate = wxPyBeginAllowThreads();
10781 wxFileSystem::CleanUpHandlers();
10782 wxPyEndAllowThreads(__tstate);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 resultobj = SWIG_Py_Void();
10786 return resultobj;
10787 fail:
10788 return NULL;
10789 }
10790
10791
10792 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj = 0;
10794 wxString *arg1 = 0 ;
10795 wxString result;
10796 bool temp1 = false ;
10797 PyObject * obj0 = 0 ;
10798 char * kwnames[] = {
10799 (char *) "filename", NULL
10800 };
10801
10802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10803 {
10804 arg1 = wxString_in_helper(obj0);
10805 if (arg1 == NULL) SWIG_fail;
10806 temp1 = true;
10807 }
10808 {
10809 PyThreadState* __tstate = wxPyBeginAllowThreads();
10810 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 {
10815 #if wxUSE_UNICODE
10816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10817 #else
10818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10819 #endif
10820 }
10821 {
10822 if (temp1)
10823 delete arg1;
10824 }
10825 return resultobj;
10826 fail:
10827 {
10828 if (temp1)
10829 delete arg1;
10830 }
10831 return NULL;
10832 }
10833
10834
10835 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10836 PyObject *resultobj = 0;
10837 wxString *arg1 = 0 ;
10838 wxString result;
10839 bool temp1 = false ;
10840 PyObject * obj0 = 0 ;
10841 char * kwnames[] = {
10842 (char *) "url", NULL
10843 };
10844
10845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10846 {
10847 arg1 = wxString_in_helper(obj0);
10848 if (arg1 == NULL) SWIG_fail;
10849 temp1 = true;
10850 }
10851 {
10852 PyThreadState* __tstate = wxPyBeginAllowThreads();
10853 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10854 wxPyEndAllowThreads(__tstate);
10855 if (PyErr_Occurred()) SWIG_fail;
10856 }
10857 {
10858 #if wxUSE_UNICODE
10859 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10860 #else
10861 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10862 #endif
10863 }
10864 {
10865 if (temp1)
10866 delete arg1;
10867 }
10868 return resultobj;
10869 fail:
10870 {
10871 if (temp1)
10872 delete arg1;
10873 }
10874 return NULL;
10875 }
10876
10877
10878 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10879 PyObject *obj;
10880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10881 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10882 return SWIG_Py_Void();
10883 }
10884
10885 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10886 return SWIG_Python_InitShadowInstance(args);
10887 }
10888
10889 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890 PyObject *resultobj = 0;
10891 wxInternetFSHandler *result = 0 ;
10892
10893 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10894 {
10895 PyThreadState* __tstate = wxPyBeginAllowThreads();
10896 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10897 wxPyEndAllowThreads(__tstate);
10898 if (PyErr_Occurred()) SWIG_fail;
10899 }
10900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10901 return resultobj;
10902 fail:
10903 return NULL;
10904 }
10905
10906
10907 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10908 PyObject *resultobj = 0;
10909 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10910 wxString *arg2 = 0 ;
10911 bool result;
10912 void *argp1 = 0 ;
10913 int res1 = 0 ;
10914 bool temp2 = false ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 char * kwnames[] = {
10918 (char *) "self",(char *) "location", NULL
10919 };
10920
10921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10923 if (!SWIG_IsOK(res1)) {
10924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10925 }
10926 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10927 {
10928 arg2 = wxString_in_helper(obj1);
10929 if (arg2 == NULL) SWIG_fail;
10930 temp2 = true;
10931 }
10932 {
10933 PyThreadState* __tstate = wxPyBeginAllowThreads();
10934 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10935 wxPyEndAllowThreads(__tstate);
10936 if (PyErr_Occurred()) SWIG_fail;
10937 }
10938 {
10939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10940 }
10941 {
10942 if (temp2)
10943 delete arg2;
10944 }
10945 return resultobj;
10946 fail:
10947 {
10948 if (temp2)
10949 delete arg2;
10950 }
10951 return NULL;
10952 }
10953
10954
10955 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10956 PyObject *resultobj = 0;
10957 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10958 wxFileSystem *arg2 = 0 ;
10959 wxString *arg3 = 0 ;
10960 wxFSFile *result = 0 ;
10961 void *argp1 = 0 ;
10962 int res1 = 0 ;
10963 void *argp2 = 0 ;
10964 int res2 = 0 ;
10965 bool temp3 = false ;
10966 PyObject * obj0 = 0 ;
10967 PyObject * obj1 = 0 ;
10968 PyObject * obj2 = 0 ;
10969 char * kwnames[] = {
10970 (char *) "self",(char *) "fs",(char *) "location", NULL
10971 };
10972
10973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10975 if (!SWIG_IsOK(res1)) {
10976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10977 }
10978 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10979 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10980 if (!SWIG_IsOK(res2)) {
10981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10982 }
10983 if (!argp2) {
10984 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10985 }
10986 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10987 {
10988 arg3 = wxString_in_helper(obj2);
10989 if (arg3 == NULL) SWIG_fail;
10990 temp3 = true;
10991 }
10992 {
10993 PyThreadState* __tstate = wxPyBeginAllowThreads();
10994 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10995 wxPyEndAllowThreads(__tstate);
10996 if (PyErr_Occurred()) SWIG_fail;
10997 }
10998 {
10999 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11000 }
11001 {
11002 if (temp3)
11003 delete arg3;
11004 }
11005 return resultobj;
11006 fail:
11007 {
11008 if (temp3)
11009 delete arg3;
11010 }
11011 return NULL;
11012 }
11013
11014
11015 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11016 PyObject *obj;
11017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11018 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11019 return SWIG_Py_Void();
11020 }
11021
11022 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11023 return SWIG_Python_InitShadowInstance(args);
11024 }
11025
11026 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11027 PyObject *resultobj = 0;
11028 wxZipFSHandler *result = 0 ;
11029
11030 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11031 {
11032 PyThreadState* __tstate = wxPyBeginAllowThreads();
11033 result = (wxZipFSHandler *)new wxZipFSHandler();
11034 wxPyEndAllowThreads(__tstate);
11035 if (PyErr_Occurred()) SWIG_fail;
11036 }
11037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11038 return resultobj;
11039 fail:
11040 return NULL;
11041 }
11042
11043
11044 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11045 PyObject *resultobj = 0;
11046 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11047 wxString *arg2 = 0 ;
11048 bool result;
11049 void *argp1 = 0 ;
11050 int res1 = 0 ;
11051 bool temp2 = false ;
11052 PyObject * obj0 = 0 ;
11053 PyObject * obj1 = 0 ;
11054 char * kwnames[] = {
11055 (char *) "self",(char *) "location", NULL
11056 };
11057
11058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11060 if (!SWIG_IsOK(res1)) {
11061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11062 }
11063 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11064 {
11065 arg2 = wxString_in_helper(obj1);
11066 if (arg2 == NULL) SWIG_fail;
11067 temp2 = true;
11068 }
11069 {
11070 PyThreadState* __tstate = wxPyBeginAllowThreads();
11071 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 {
11076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11077 }
11078 {
11079 if (temp2)
11080 delete arg2;
11081 }
11082 return resultobj;
11083 fail:
11084 {
11085 if (temp2)
11086 delete arg2;
11087 }
11088 return NULL;
11089 }
11090
11091
11092 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11093 PyObject *resultobj = 0;
11094 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11095 wxFileSystem *arg2 = 0 ;
11096 wxString *arg3 = 0 ;
11097 wxFSFile *result = 0 ;
11098 void *argp1 = 0 ;
11099 int res1 = 0 ;
11100 void *argp2 = 0 ;
11101 int res2 = 0 ;
11102 bool temp3 = false ;
11103 PyObject * obj0 = 0 ;
11104 PyObject * obj1 = 0 ;
11105 PyObject * obj2 = 0 ;
11106 char * kwnames[] = {
11107 (char *) "self",(char *) "fs",(char *) "location", NULL
11108 };
11109
11110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11112 if (!SWIG_IsOK(res1)) {
11113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11114 }
11115 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11117 if (!SWIG_IsOK(res2)) {
11118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11119 }
11120 if (!argp2) {
11121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11122 }
11123 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11124 {
11125 arg3 = wxString_in_helper(obj2);
11126 if (arg3 == NULL) SWIG_fail;
11127 temp3 = true;
11128 }
11129 {
11130 PyThreadState* __tstate = wxPyBeginAllowThreads();
11131 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11132 wxPyEndAllowThreads(__tstate);
11133 if (PyErr_Occurred()) SWIG_fail;
11134 }
11135 {
11136 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11137 }
11138 {
11139 if (temp3)
11140 delete arg3;
11141 }
11142 return resultobj;
11143 fail:
11144 {
11145 if (temp3)
11146 delete arg3;
11147 }
11148 return NULL;
11149 }
11150
11151
11152 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj = 0;
11154 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11155 wxString *arg2 = 0 ;
11156 int arg3 = (int) 0 ;
11157 wxString result;
11158 void *argp1 = 0 ;
11159 int res1 = 0 ;
11160 bool temp2 = false ;
11161 int val3 ;
11162 int ecode3 = 0 ;
11163 PyObject * obj0 = 0 ;
11164 PyObject * obj1 = 0 ;
11165 PyObject * obj2 = 0 ;
11166 char * kwnames[] = {
11167 (char *) "self",(char *) "spec",(char *) "flags", NULL
11168 };
11169
11170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11172 if (!SWIG_IsOK(res1)) {
11173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11174 }
11175 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11176 {
11177 arg2 = wxString_in_helper(obj1);
11178 if (arg2 == NULL) SWIG_fail;
11179 temp2 = true;
11180 }
11181 if (obj2) {
11182 ecode3 = SWIG_AsVal_int(obj2, &val3);
11183 if (!SWIG_IsOK(ecode3)) {
11184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11185 }
11186 arg3 = static_cast< int >(val3);
11187 }
11188 {
11189 PyThreadState* __tstate = wxPyBeginAllowThreads();
11190 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11191 wxPyEndAllowThreads(__tstate);
11192 if (PyErr_Occurred()) SWIG_fail;
11193 }
11194 {
11195 #if wxUSE_UNICODE
11196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11197 #else
11198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11199 #endif
11200 }
11201 {
11202 if (temp2)
11203 delete arg2;
11204 }
11205 return resultobj;
11206 fail:
11207 {
11208 if (temp2)
11209 delete arg2;
11210 }
11211 return NULL;
11212 }
11213
11214
11215 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11216 PyObject *resultobj = 0;
11217 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11218 wxString result;
11219 void *argp1 = 0 ;
11220 int res1 = 0 ;
11221 PyObject *swig_obj[1] ;
11222
11223 if (!args) SWIG_fail;
11224 swig_obj[0] = args;
11225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11226 if (!SWIG_IsOK(res1)) {
11227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11228 }
11229 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11230 {
11231 PyThreadState* __tstate = wxPyBeginAllowThreads();
11232 result = (arg1)->FindNext();
11233 wxPyEndAllowThreads(__tstate);
11234 if (PyErr_Occurred()) SWIG_fail;
11235 }
11236 {
11237 #if wxUSE_UNICODE
11238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11239 #else
11240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11241 #endif
11242 }
11243 return resultobj;
11244 fail:
11245 return NULL;
11246 }
11247
11248
11249 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11250 PyObject *obj;
11251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11252 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11253 return SWIG_Py_Void();
11254 }
11255
11256 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257 return SWIG_Python_InitShadowInstance(args);
11258 }
11259
11260 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11261 PyObject *resultobj = 0;
11262 wxString *arg1 = 0 ;
11263 wxImage *arg2 = 0 ;
11264 long arg3 ;
11265 bool temp1 = false ;
11266 void *argp2 = 0 ;
11267 int res2 = 0 ;
11268 long val3 ;
11269 int ecode3 = 0 ;
11270 PyObject * obj0 = 0 ;
11271 PyObject * obj1 = 0 ;
11272 PyObject * obj2 = 0 ;
11273 char * kwnames[] = {
11274 (char *) "filename",(char *) "image",(char *) "type", NULL
11275 };
11276
11277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11278 {
11279 arg1 = wxString_in_helper(obj0);
11280 if (arg1 == NULL) SWIG_fail;
11281 temp1 = true;
11282 }
11283 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11284 if (!SWIG_IsOK(res2)) {
11285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11286 }
11287 if (!argp2) {
11288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11289 }
11290 arg2 = reinterpret_cast< wxImage * >(argp2);
11291 ecode3 = SWIG_AsVal_long(obj2, &val3);
11292 if (!SWIG_IsOK(ecode3)) {
11293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11294 }
11295 arg3 = static_cast< long >(val3);
11296 {
11297 PyThreadState* __tstate = wxPyBeginAllowThreads();
11298 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 resultobj = SWIG_Py_Void();
11303 {
11304 if (temp1)
11305 delete arg1;
11306 }
11307 return resultobj;
11308 fail:
11309 {
11310 if (temp1)
11311 delete arg1;
11312 }
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11318 PyObject *resultobj = 0;
11319 wxString *arg1 = 0 ;
11320 wxBitmap *arg2 = 0 ;
11321 long arg3 ;
11322 bool temp1 = false ;
11323 void *argp2 = 0 ;
11324 int res2 = 0 ;
11325 long val3 ;
11326 int ecode3 = 0 ;
11327 PyObject * obj0 = 0 ;
11328 PyObject * obj1 = 0 ;
11329 PyObject * obj2 = 0 ;
11330 char * kwnames[] = {
11331 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11332 };
11333
11334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11335 {
11336 arg1 = wxString_in_helper(obj0);
11337 if (arg1 == NULL) SWIG_fail;
11338 temp1 = true;
11339 }
11340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11341 if (!SWIG_IsOK(res2)) {
11342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11343 }
11344 if (!argp2) {
11345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11346 }
11347 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11348 ecode3 = SWIG_AsVal_long(obj2, &val3);
11349 if (!SWIG_IsOK(ecode3)) {
11350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11351 }
11352 arg3 = static_cast< long >(val3);
11353 {
11354 PyThreadState* __tstate = wxPyBeginAllowThreads();
11355 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11356 wxPyEndAllowThreads(__tstate);
11357 if (PyErr_Occurred()) SWIG_fail;
11358 }
11359 resultobj = SWIG_Py_Void();
11360 {
11361 if (temp1)
11362 delete arg1;
11363 }
11364 return resultobj;
11365 fail:
11366 {
11367 if (temp1)
11368 delete arg1;
11369 }
11370 return NULL;
11371 }
11372
11373
11374 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11375 PyObject *resultobj = 0;
11376 wxString *arg1 = 0 ;
11377 PyObject *arg2 = (PyObject *) 0 ;
11378 bool temp1 = false ;
11379 PyObject * obj0 = 0 ;
11380 PyObject * obj1 = 0 ;
11381 char * kwnames[] = {
11382 (char *) "filename",(char *) "data", NULL
11383 };
11384
11385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11386 {
11387 arg1 = wxString_in_helper(obj0);
11388 if (arg1 == NULL) SWIG_fail;
11389 temp1 = true;
11390 }
11391 arg2 = obj1;
11392 {
11393 PyThreadState* __tstate = wxPyBeginAllowThreads();
11394 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 resultobj = SWIG_Py_Void();
11399 {
11400 if (temp1)
11401 delete arg1;
11402 }
11403 return resultobj;
11404 fail:
11405 {
11406 if (temp1)
11407 delete arg1;
11408 }
11409 return NULL;
11410 }
11411
11412
11413 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11414 PyObject *resultobj = 0;
11415 wxMemoryFSHandler *result = 0 ;
11416
11417 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11418 {
11419 PyThreadState* __tstate = wxPyBeginAllowThreads();
11420 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11421 wxPyEndAllowThreads(__tstate);
11422 if (PyErr_Occurred()) SWIG_fail;
11423 }
11424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11425 return resultobj;
11426 fail:
11427 return NULL;
11428 }
11429
11430
11431 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxString *arg1 = 0 ;
11434 bool temp1 = false ;
11435 PyObject * obj0 = 0 ;
11436 char * kwnames[] = {
11437 (char *) "filename", NULL
11438 };
11439
11440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11441 {
11442 arg1 = wxString_in_helper(obj0);
11443 if (arg1 == NULL) SWIG_fail;
11444 temp1 = true;
11445 }
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11449 wxPyEndAllowThreads(__tstate);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 resultobj = SWIG_Py_Void();
11453 {
11454 if (temp1)
11455 delete arg1;
11456 }
11457 return resultobj;
11458 fail:
11459 {
11460 if (temp1)
11461 delete arg1;
11462 }
11463 return NULL;
11464 }
11465
11466
11467 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11468 PyObject *resultobj = 0;
11469 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11470 wxString *arg2 = 0 ;
11471 bool result;
11472 void *argp1 = 0 ;
11473 int res1 = 0 ;
11474 bool temp2 = false ;
11475 PyObject * obj0 = 0 ;
11476 PyObject * obj1 = 0 ;
11477 char * kwnames[] = {
11478 (char *) "self",(char *) "location", NULL
11479 };
11480
11481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11483 if (!SWIG_IsOK(res1)) {
11484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11485 }
11486 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11487 {
11488 arg2 = wxString_in_helper(obj1);
11489 if (arg2 == NULL) SWIG_fail;
11490 temp2 = true;
11491 }
11492 {
11493 PyThreadState* __tstate = wxPyBeginAllowThreads();
11494 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11495 wxPyEndAllowThreads(__tstate);
11496 if (PyErr_Occurred()) SWIG_fail;
11497 }
11498 {
11499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11500 }
11501 {
11502 if (temp2)
11503 delete arg2;
11504 }
11505 return resultobj;
11506 fail:
11507 {
11508 if (temp2)
11509 delete arg2;
11510 }
11511 return NULL;
11512 }
11513
11514
11515 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11516 PyObject *resultobj = 0;
11517 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11518 wxFileSystem *arg2 = 0 ;
11519 wxString *arg3 = 0 ;
11520 wxFSFile *result = 0 ;
11521 void *argp1 = 0 ;
11522 int res1 = 0 ;
11523 void *argp2 = 0 ;
11524 int res2 = 0 ;
11525 bool temp3 = false ;
11526 PyObject * obj0 = 0 ;
11527 PyObject * obj1 = 0 ;
11528 PyObject * obj2 = 0 ;
11529 char * kwnames[] = {
11530 (char *) "self",(char *) "fs",(char *) "location", NULL
11531 };
11532
11533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11535 if (!SWIG_IsOK(res1)) {
11536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11537 }
11538 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11540 if (!SWIG_IsOK(res2)) {
11541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11542 }
11543 if (!argp2) {
11544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11545 }
11546 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11547 {
11548 arg3 = wxString_in_helper(obj2);
11549 if (arg3 == NULL) SWIG_fail;
11550 temp3 = true;
11551 }
11552 {
11553 PyThreadState* __tstate = wxPyBeginAllowThreads();
11554 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11555 wxPyEndAllowThreads(__tstate);
11556 if (PyErr_Occurred()) SWIG_fail;
11557 }
11558 {
11559 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11560 }
11561 {
11562 if (temp3)
11563 delete arg3;
11564 }
11565 return resultobj;
11566 fail:
11567 {
11568 if (temp3)
11569 delete arg3;
11570 }
11571 return NULL;
11572 }
11573
11574
11575 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11576 PyObject *resultobj = 0;
11577 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11578 wxString *arg2 = 0 ;
11579 int arg3 = (int) 0 ;
11580 wxString result;
11581 void *argp1 = 0 ;
11582 int res1 = 0 ;
11583 bool temp2 = false ;
11584 int val3 ;
11585 int ecode3 = 0 ;
11586 PyObject * obj0 = 0 ;
11587 PyObject * obj1 = 0 ;
11588 PyObject * obj2 = 0 ;
11589 char * kwnames[] = {
11590 (char *) "self",(char *) "spec",(char *) "flags", NULL
11591 };
11592
11593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11595 if (!SWIG_IsOK(res1)) {
11596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11597 }
11598 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11599 {
11600 arg2 = wxString_in_helper(obj1);
11601 if (arg2 == NULL) SWIG_fail;
11602 temp2 = true;
11603 }
11604 if (obj2) {
11605 ecode3 = SWIG_AsVal_int(obj2, &val3);
11606 if (!SWIG_IsOK(ecode3)) {
11607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11608 }
11609 arg3 = static_cast< int >(val3);
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11614 wxPyEndAllowThreads(__tstate);
11615 if (PyErr_Occurred()) SWIG_fail;
11616 }
11617 {
11618 #if wxUSE_UNICODE
11619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11620 #else
11621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11622 #endif
11623 }
11624 {
11625 if (temp2)
11626 delete arg2;
11627 }
11628 return resultobj;
11629 fail:
11630 {
11631 if (temp2)
11632 delete arg2;
11633 }
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11639 PyObject *resultobj = 0;
11640 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11641 wxString result;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 PyObject *swig_obj[1] ;
11645
11646 if (!args) SWIG_fail;
11647 swig_obj[0] = args;
11648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11651 }
11652 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (arg1)->FindNext();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 {
11660 #if wxUSE_UNICODE
11661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11662 #else
11663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11664 #endif
11665 }
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11673 PyObject *obj;
11674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11675 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11676 return SWIG_Py_Void();
11677 }
11678
11679 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 return SWIG_Python_InitShadowInstance(args);
11681 }
11682
11683 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11684 PyObject *resultobj = 0;
11685 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11686 wxString result;
11687 void *argp1 = 0 ;
11688 int res1 = 0 ;
11689 PyObject *swig_obj[1] ;
11690
11691 if (!args) SWIG_fail;
11692 swig_obj[0] = args;
11693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11694 if (!SWIG_IsOK(res1)) {
11695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11696 }
11697 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = (arg1)->GetName();
11701 wxPyEndAllowThreads(__tstate);
11702 if (PyErr_Occurred()) SWIG_fail;
11703 }
11704 {
11705 #if wxUSE_UNICODE
11706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11707 #else
11708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11709 #endif
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11718 PyObject *resultobj = 0;
11719 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11720 wxString result;
11721 void *argp1 = 0 ;
11722 int res1 = 0 ;
11723 PyObject *swig_obj[1] ;
11724
11725 if (!args) SWIG_fail;
11726 swig_obj[0] = args;
11727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11728 if (!SWIG_IsOK(res1)) {
11729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11730 }
11731 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11732 {
11733 PyThreadState* __tstate = wxPyBeginAllowThreads();
11734 result = (arg1)->GetExtension();
11735 wxPyEndAllowThreads(__tstate);
11736 if (PyErr_Occurred()) SWIG_fail;
11737 }
11738 {
11739 #if wxUSE_UNICODE
11740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11741 #else
11742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11743 #endif
11744 }
11745 return resultobj;
11746 fail:
11747 return NULL;
11748 }
11749
11750
11751 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11752 PyObject *resultobj = 0;
11753 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11754 long result;
11755 void *argp1 = 0 ;
11756 int res1 = 0 ;
11757 PyObject *swig_obj[1] ;
11758
11759 if (!args) SWIG_fail;
11760 swig_obj[0] = args;
11761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11762 if (!SWIG_IsOK(res1)) {
11763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11764 }
11765 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (long)(arg1)->GetType();
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 resultobj = SWIG_From_long(static_cast< long >(result));
11773 return resultobj;
11774 fail:
11775 return NULL;
11776 }
11777
11778
11779 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11780 PyObject *resultobj = 0;
11781 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11782 wxString result;
11783 void *argp1 = 0 ;
11784 int res1 = 0 ;
11785 PyObject *swig_obj[1] ;
11786
11787 if (!args) SWIG_fail;
11788 swig_obj[0] = args;
11789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11790 if (!SWIG_IsOK(res1)) {
11791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11792 }
11793 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11794 {
11795 PyThreadState* __tstate = wxPyBeginAllowThreads();
11796 result = (arg1)->GetMimeType();
11797 wxPyEndAllowThreads(__tstate);
11798 if (PyErr_Occurred()) SWIG_fail;
11799 }
11800 {
11801 #if wxUSE_UNICODE
11802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11803 #else
11804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11805 #endif
11806 }
11807 return resultobj;
11808 fail:
11809 return NULL;
11810 }
11811
11812
11813 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11814 PyObject *resultobj = 0;
11815 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11816 wxString *arg2 = 0 ;
11817 bool result;
11818 void *argp1 = 0 ;
11819 int res1 = 0 ;
11820 bool temp2 = false ;
11821 PyObject * obj0 = 0 ;
11822 PyObject * obj1 = 0 ;
11823 char * kwnames[] = {
11824 (char *) "self",(char *) "name", NULL
11825 };
11826
11827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11829 if (!SWIG_IsOK(res1)) {
11830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11831 }
11832 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11833 {
11834 arg2 = wxString_in_helper(obj1);
11835 if (arg2 == NULL) SWIG_fail;
11836 temp2 = true;
11837 }
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11841 wxPyEndAllowThreads(__tstate);
11842 if (PyErr_Occurred()) SWIG_fail;
11843 }
11844 {
11845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11846 }
11847 {
11848 if (temp2)
11849 delete arg2;
11850 }
11851 return resultobj;
11852 fail:
11853 {
11854 if (temp2)
11855 delete arg2;
11856 }
11857 return NULL;
11858 }
11859
11860
11861 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11862 PyObject *resultobj = 0;
11863 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11864 wxString *arg2 = 0 ;
11865 void *argp1 = 0 ;
11866 int res1 = 0 ;
11867 bool temp2 = false ;
11868 PyObject * obj0 = 0 ;
11869 PyObject * obj1 = 0 ;
11870 char * kwnames[] = {
11871 (char *) "self",(char *) "name", NULL
11872 };
11873
11874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11878 }
11879 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11880 {
11881 arg2 = wxString_in_helper(obj1);
11882 if (arg2 == NULL) SWIG_fail;
11883 temp2 = true;
11884 }
11885 {
11886 PyThreadState* __tstate = wxPyBeginAllowThreads();
11887 (arg1)->SetName((wxString const &)*arg2);
11888 wxPyEndAllowThreads(__tstate);
11889 if (PyErr_Occurred()) SWIG_fail;
11890 }
11891 resultobj = SWIG_Py_Void();
11892 {
11893 if (temp2)
11894 delete arg2;
11895 }
11896 return resultobj;
11897 fail:
11898 {
11899 if (temp2)
11900 delete arg2;
11901 }
11902 return NULL;
11903 }
11904
11905
11906 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11907 PyObject *resultobj = 0;
11908 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11909 wxString *arg2 = 0 ;
11910 void *argp1 = 0 ;
11911 int res1 = 0 ;
11912 bool temp2 = false ;
11913 PyObject * obj0 = 0 ;
11914 PyObject * obj1 = 0 ;
11915 char * kwnames[] = {
11916 (char *) "self",(char *) "extension", NULL
11917 };
11918
11919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11921 if (!SWIG_IsOK(res1)) {
11922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11923 }
11924 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11925 {
11926 arg2 = wxString_in_helper(obj1);
11927 if (arg2 == NULL) SWIG_fail;
11928 temp2 = true;
11929 }
11930 {
11931 PyThreadState* __tstate = wxPyBeginAllowThreads();
11932 (arg1)->SetExtension((wxString const &)*arg2);
11933 wxPyEndAllowThreads(__tstate);
11934 if (PyErr_Occurred()) SWIG_fail;
11935 }
11936 resultobj = SWIG_Py_Void();
11937 {
11938 if (temp2)
11939 delete arg2;
11940 }
11941 return resultobj;
11942 fail:
11943 {
11944 if (temp2)
11945 delete arg2;
11946 }
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11952 PyObject *resultobj = 0;
11953 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11954 long arg2 ;
11955 void *argp1 = 0 ;
11956 int res1 = 0 ;
11957 long val2 ;
11958 int ecode2 = 0 ;
11959 PyObject * obj0 = 0 ;
11960 PyObject * obj1 = 0 ;
11961 char * kwnames[] = {
11962 (char *) "self",(char *) "type", NULL
11963 };
11964
11965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11967 if (!SWIG_IsOK(res1)) {
11968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11969 }
11970 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11971 ecode2 = SWIG_AsVal_long(obj1, &val2);
11972 if (!SWIG_IsOK(ecode2)) {
11973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11974 }
11975 arg2 = static_cast< long >(val2);
11976 {
11977 PyThreadState* __tstate = wxPyBeginAllowThreads();
11978 (arg1)->SetType(arg2);
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 resultobj = SWIG_Py_Void();
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj = 0;
11991 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11992 wxString *arg2 = 0 ;
11993 void *argp1 = 0 ;
11994 int res1 = 0 ;
11995 bool temp2 = false ;
11996 PyObject * obj0 = 0 ;
11997 PyObject * obj1 = 0 ;
11998 char * kwnames[] = {
11999 (char *) "self",(char *) "mimetype", NULL
12000 };
12001
12002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12004 if (!SWIG_IsOK(res1)) {
12005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12006 }
12007 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12008 {
12009 arg2 = wxString_in_helper(obj1);
12010 if (arg2 == NULL) SWIG_fail;
12011 temp2 = true;
12012 }
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 (arg1)->SetMimeType((wxString const &)*arg2);
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 resultobj = SWIG_Py_Void();
12020 {
12021 if (temp2)
12022 delete arg2;
12023 }
12024 return resultobj;
12025 fail:
12026 {
12027 if (temp2)
12028 delete arg2;
12029 }
12030 return NULL;
12031 }
12032
12033
12034 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12035 PyObject *obj;
12036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12037 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12038 return SWIG_Py_Void();
12039 }
12040
12041 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12042 PyObject *resultobj = 0;
12043 wxPyImageHandler *result = 0 ;
12044
12045 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12046 {
12047 PyThreadState* __tstate = wxPyBeginAllowThreads();
12048 result = (wxPyImageHandler *)new wxPyImageHandler();
12049 wxPyEndAllowThreads(__tstate);
12050 if (PyErr_Occurred()) SWIG_fail;
12051 }
12052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12053 return resultobj;
12054 fail:
12055 return NULL;
12056 }
12057
12058
12059 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj = 0;
12061 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12062 PyObject *arg2 = (PyObject *) 0 ;
12063 void *argp1 = 0 ;
12064 int res1 = 0 ;
12065 PyObject * obj0 = 0 ;
12066 PyObject * obj1 = 0 ;
12067 char * kwnames[] = {
12068 (char *) "self",(char *) "self", NULL
12069 };
12070
12071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12073 if (!SWIG_IsOK(res1)) {
12074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12075 }
12076 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12077 arg2 = obj1;
12078 {
12079 PyThreadState* __tstate = wxPyBeginAllowThreads();
12080 (arg1)->_SetSelf(arg2);
12081 wxPyEndAllowThreads(__tstate);
12082 if (PyErr_Occurred()) SWIG_fail;
12083 }
12084 resultobj = SWIG_Py_Void();
12085 return resultobj;
12086 fail:
12087 return NULL;
12088 }
12089
12090
12091 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12092 PyObject *obj;
12093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12094 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12095 return SWIG_Py_Void();
12096 }
12097
12098 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12099 return SWIG_Python_InitShadowInstance(args);
12100 }
12101
12102 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12103 PyObject *resultobj = 0;
12104 wxImageHistogram *result = 0 ;
12105
12106 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12107 {
12108 PyThreadState* __tstate = wxPyBeginAllowThreads();
12109 result = (wxImageHistogram *)new wxImageHistogram();
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12114 return resultobj;
12115 fail:
12116 return NULL;
12117 }
12118
12119
12120 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12121 PyObject *resultobj = 0;
12122 byte arg1 ;
12123 byte arg2 ;
12124 byte arg3 ;
12125 unsigned long result;
12126 unsigned char val1 ;
12127 int ecode1 = 0 ;
12128 unsigned char val2 ;
12129 int ecode2 = 0 ;
12130 unsigned char val3 ;
12131 int ecode3 = 0 ;
12132 PyObject * obj0 = 0 ;
12133 PyObject * obj1 = 0 ;
12134 PyObject * obj2 = 0 ;
12135 char * kwnames[] = {
12136 (char *) "r",(char *) "g",(char *) "b", NULL
12137 };
12138
12139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12140 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12141 if (!SWIG_IsOK(ecode1)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12143 }
12144 arg1 = static_cast< byte >(val1);
12145 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12146 if (!SWIG_IsOK(ecode2)) {
12147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12148 }
12149 arg2 = static_cast< byte >(val2);
12150 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12151 if (!SWIG_IsOK(ecode3)) {
12152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12153 }
12154 arg3 = static_cast< byte >(val3);
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12162 return resultobj;
12163 fail:
12164 return NULL;
12165 }
12166
12167
12168 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12169 PyObject *resultobj = 0;
12170 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12171 byte *arg2 = (byte *) 0 ;
12172 byte *arg3 = (byte *) 0 ;
12173 byte *arg4 = (byte *) 0 ;
12174 byte arg5 = (byte) 1 ;
12175 byte arg6 = (byte) 0 ;
12176 byte arg7 = (byte) 0 ;
12177 bool result;
12178 void *argp1 = 0 ;
12179 int res1 = 0 ;
12180 byte temp2 ;
12181 int res2 = SWIG_TMPOBJ ;
12182 byte temp3 ;
12183 int res3 = SWIG_TMPOBJ ;
12184 byte temp4 ;
12185 int res4 = SWIG_TMPOBJ ;
12186 unsigned char val5 ;
12187 int ecode5 = 0 ;
12188 unsigned char val6 ;
12189 int ecode6 = 0 ;
12190 unsigned char val7 ;
12191 int ecode7 = 0 ;
12192 PyObject * obj0 = 0 ;
12193 PyObject * obj1 = 0 ;
12194 PyObject * obj2 = 0 ;
12195 PyObject * obj3 = 0 ;
12196 char * kwnames[] = {
12197 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12198 };
12199
12200 arg2 = &temp2;
12201 arg3 = &temp3;
12202 arg4 = &temp4;
12203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12205 if (!SWIG_IsOK(res1)) {
12206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12207 }
12208 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12209 if (obj1) {
12210 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12211 if (!SWIG_IsOK(ecode5)) {
12212 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12213 }
12214 arg5 = static_cast< byte >(val5);
12215 }
12216 if (obj2) {
12217 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12218 if (!SWIG_IsOK(ecode6)) {
12219 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12220 }
12221 arg6 = static_cast< byte >(val6);
12222 }
12223 if (obj3) {
12224 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12225 if (!SWIG_IsOK(ecode7)) {
12226 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12227 }
12228 arg7 = static_cast< byte >(val7);
12229 }
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 {
12237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12238 }
12239 if (SWIG_IsTmpObj(res2)) {
12240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12241 } else {
12242 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12244 }
12245 if (SWIG_IsTmpObj(res3)) {
12246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12247 } else {
12248 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12250 }
12251 if (SWIG_IsTmpObj(res4)) {
12252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12253 } else {
12254 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12256 }
12257 return resultobj;
12258 fail:
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12264 PyObject *resultobj = 0;
12265 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12266 unsigned long arg2 ;
12267 unsigned long result;
12268 void *argp1 = 0 ;
12269 int res1 = 0 ;
12270 unsigned long val2 ;
12271 int ecode2 = 0 ;
12272 PyObject * obj0 = 0 ;
12273 PyObject * obj1 = 0 ;
12274 char * kwnames[] = {
12275 (char *) "self",(char *) "key", NULL
12276 };
12277
12278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12280 if (!SWIG_IsOK(res1)) {
12281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12282 }
12283 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12284 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12285 if (!SWIG_IsOK(ecode2)) {
12286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12287 }
12288 arg2 = static_cast< unsigned long >(val2);
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12303 PyObject *resultobj = 0;
12304 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12305 byte arg2 ;
12306 byte arg3 ;
12307 byte arg4 ;
12308 unsigned long result;
12309 void *argp1 = 0 ;
12310 int res1 = 0 ;
12311 unsigned char val2 ;
12312 int ecode2 = 0 ;
12313 unsigned char val3 ;
12314 int ecode3 = 0 ;
12315 unsigned char val4 ;
12316 int ecode4 = 0 ;
12317 PyObject * obj0 = 0 ;
12318 PyObject * obj1 = 0 ;
12319 PyObject * obj2 = 0 ;
12320 PyObject * obj3 = 0 ;
12321 char * kwnames[] = {
12322 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12323 };
12324
12325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12327 if (!SWIG_IsOK(res1)) {
12328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12329 }
12330 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12331 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12332 if (!SWIG_IsOK(ecode2)) {
12333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12334 }
12335 arg2 = static_cast< byte >(val2);
12336 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12337 if (!SWIG_IsOK(ecode3)) {
12338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12339 }
12340 arg3 = static_cast< byte >(val3);
12341 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12342 if (!SWIG_IsOK(ecode4)) {
12343 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12344 }
12345 arg4 = static_cast< byte >(val4);
12346 {
12347 PyThreadState* __tstate = wxPyBeginAllowThreads();
12348 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12349 wxPyEndAllowThreads(__tstate);
12350 if (PyErr_Occurred()) SWIG_fail;
12351 }
12352 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj = 0;
12361 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12362 wxColour *arg2 = 0 ;
12363 unsigned long result;
12364 void *argp1 = 0 ;
12365 int res1 = 0 ;
12366 wxColour temp2 ;
12367 PyObject * obj0 = 0 ;
12368 PyObject * obj1 = 0 ;
12369 char * kwnames[] = {
12370 (char *) "self",(char *) "colour", NULL
12371 };
12372
12373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12377 }
12378 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12379 {
12380 arg2 = &temp2;
12381 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12382 }
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12386 wxPyEndAllowThreads(__tstate);
12387 if (PyErr_Occurred()) SWIG_fail;
12388 }
12389 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12390 return resultobj;
12391 fail:
12392 return NULL;
12393 }
12394
12395
12396 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12397 PyObject *obj;
12398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12399 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12400 return SWIG_Py_Void();
12401 }
12402
12403 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12404 return SWIG_Python_InitShadowInstance(args);
12405 }
12406
12407 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj = 0;
12409 byte arg1 = (byte) 0 ;
12410 byte arg2 = (byte) 0 ;
12411 byte arg3 = (byte) 0 ;
12412 wxImage_RGBValue *result = 0 ;
12413 unsigned char val1 ;
12414 int ecode1 = 0 ;
12415 unsigned char val2 ;
12416 int ecode2 = 0 ;
12417 unsigned char val3 ;
12418 int ecode3 = 0 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 PyObject * obj2 = 0 ;
12422 char * kwnames[] = {
12423 (char *) "r",(char *) "g",(char *) "b", NULL
12424 };
12425
12426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12427 if (obj0) {
12428 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12429 if (!SWIG_IsOK(ecode1)) {
12430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12431 }
12432 arg1 = static_cast< byte >(val1);
12433 }
12434 if (obj1) {
12435 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12436 if (!SWIG_IsOK(ecode2)) {
12437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12438 }
12439 arg2 = static_cast< byte >(val2);
12440 }
12441 if (obj2) {
12442 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12443 if (!SWIG_IsOK(ecode3)) {
12444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12445 }
12446 arg3 = static_cast< byte >(val3);
12447 }
12448 {
12449 PyThreadState* __tstate = wxPyBeginAllowThreads();
12450 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12451 wxPyEndAllowThreads(__tstate);
12452 if (PyErr_Occurred()) SWIG_fail;
12453 }
12454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12455 return resultobj;
12456 fail:
12457 return NULL;
12458 }
12459
12460
12461 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12462 PyObject *resultobj = 0;
12463 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12464 byte arg2 ;
12465 void *argp1 = 0 ;
12466 int res1 = 0 ;
12467 unsigned char val2 ;
12468 int ecode2 = 0 ;
12469 PyObject *swig_obj[2] ;
12470
12471 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12473 if (!SWIG_IsOK(res1)) {
12474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12475 }
12476 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12477 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12478 if (!SWIG_IsOK(ecode2)) {
12479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12480 }
12481 arg2 = static_cast< byte >(val2);
12482 if (arg1) (arg1)->red = arg2;
12483
12484 resultobj = SWIG_Py_Void();
12485 return resultobj;
12486 fail:
12487 return NULL;
12488 }
12489
12490
12491 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12492 PyObject *resultobj = 0;
12493 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12494 byte result;
12495 void *argp1 = 0 ;
12496 int res1 = 0 ;
12497 PyObject *swig_obj[1] ;
12498
12499 if (!args) SWIG_fail;
12500 swig_obj[0] = args;
12501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12502 if (!SWIG_IsOK(res1)) {
12503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12504 }
12505 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12506 result = (byte) ((arg1)->red);
12507 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 PyObject *resultobj = 0;
12516 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12517 byte arg2 ;
12518 void *argp1 = 0 ;
12519 int res1 = 0 ;
12520 unsigned char val2 ;
12521 int ecode2 = 0 ;
12522 PyObject *swig_obj[2] ;
12523
12524 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12526 if (!SWIG_IsOK(res1)) {
12527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12528 }
12529 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12530 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12531 if (!SWIG_IsOK(ecode2)) {
12532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12533 }
12534 arg2 = static_cast< byte >(val2);
12535 if (arg1) (arg1)->green = arg2;
12536
12537 resultobj = SWIG_Py_Void();
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12545 PyObject *resultobj = 0;
12546 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12547 byte result;
12548 void *argp1 = 0 ;
12549 int res1 = 0 ;
12550 PyObject *swig_obj[1] ;
12551
12552 if (!args) SWIG_fail;
12553 swig_obj[0] = args;
12554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12555 if (!SWIG_IsOK(res1)) {
12556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12557 }
12558 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12559 result = (byte) ((arg1)->green);
12560 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12568 PyObject *resultobj = 0;
12569 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12570 byte arg2 ;
12571 void *argp1 = 0 ;
12572 int res1 = 0 ;
12573 unsigned char val2 ;
12574 int ecode2 = 0 ;
12575 PyObject *swig_obj[2] ;
12576
12577 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12579 if (!SWIG_IsOK(res1)) {
12580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12581 }
12582 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12583 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12584 if (!SWIG_IsOK(ecode2)) {
12585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12586 }
12587 arg2 = static_cast< byte >(val2);
12588 if (arg1) (arg1)->blue = arg2;
12589
12590 resultobj = SWIG_Py_Void();
12591 return resultobj;
12592 fail:
12593 return NULL;
12594 }
12595
12596
12597 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12598 PyObject *resultobj = 0;
12599 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12600 byte result;
12601 void *argp1 = 0 ;
12602 int res1 = 0 ;
12603 PyObject *swig_obj[1] ;
12604
12605 if (!args) SWIG_fail;
12606 swig_obj[0] = args;
12607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12608 if (!SWIG_IsOK(res1)) {
12609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12610 }
12611 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12612 result = (byte) ((arg1)->blue);
12613 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12614 return resultobj;
12615 fail:
12616 return NULL;
12617 }
12618
12619
12620 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12621 PyObject *obj;
12622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12623 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12624 return SWIG_Py_Void();
12625 }
12626
12627 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12628 return SWIG_Python_InitShadowInstance(args);
12629 }
12630
12631 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12632 PyObject *resultobj = 0;
12633 double arg1 = (double) 0.0 ;
12634 double arg2 = (double) 0.0 ;
12635 double arg3 = (double) 0.0 ;
12636 wxImage_HSVValue *result = 0 ;
12637 double val1 ;
12638 int ecode1 = 0 ;
12639 double val2 ;
12640 int ecode2 = 0 ;
12641 double val3 ;
12642 int ecode3 = 0 ;
12643 PyObject * obj0 = 0 ;
12644 PyObject * obj1 = 0 ;
12645 PyObject * obj2 = 0 ;
12646 char * kwnames[] = {
12647 (char *) "h",(char *) "s",(char *) "v", NULL
12648 };
12649
12650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12651 if (obj0) {
12652 ecode1 = SWIG_AsVal_double(obj0, &val1);
12653 if (!SWIG_IsOK(ecode1)) {
12654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12655 }
12656 arg1 = static_cast< double >(val1);
12657 }
12658 if (obj1) {
12659 ecode2 = SWIG_AsVal_double(obj1, &val2);
12660 if (!SWIG_IsOK(ecode2)) {
12661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12662 }
12663 arg2 = static_cast< double >(val2);
12664 }
12665 if (obj2) {
12666 ecode3 = SWIG_AsVal_double(obj2, &val3);
12667 if (!SWIG_IsOK(ecode3)) {
12668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12669 }
12670 arg3 = static_cast< double >(val3);
12671 }
12672 {
12673 PyThreadState* __tstate = wxPyBeginAllowThreads();
12674 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12675 wxPyEndAllowThreads(__tstate);
12676 if (PyErr_Occurred()) SWIG_fail;
12677 }
12678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12679 return resultobj;
12680 fail:
12681 return NULL;
12682 }
12683
12684
12685 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12686 PyObject *resultobj = 0;
12687 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12688 double arg2 ;
12689 void *argp1 = 0 ;
12690 int res1 = 0 ;
12691 double val2 ;
12692 int ecode2 = 0 ;
12693 PyObject *swig_obj[2] ;
12694
12695 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12697 if (!SWIG_IsOK(res1)) {
12698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12699 }
12700 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12701 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12702 if (!SWIG_IsOK(ecode2)) {
12703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12704 }
12705 arg2 = static_cast< double >(val2);
12706 if (arg1) (arg1)->hue = arg2;
12707
12708 resultobj = SWIG_Py_Void();
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12716 PyObject *resultobj = 0;
12717 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12718 double result;
12719 void *argp1 = 0 ;
12720 int res1 = 0 ;
12721 PyObject *swig_obj[1] ;
12722
12723 if (!args) SWIG_fail;
12724 swig_obj[0] = args;
12725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12726 if (!SWIG_IsOK(res1)) {
12727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12728 }
12729 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12730 result = (double) ((arg1)->hue);
12731 resultobj = SWIG_From_double(static_cast< double >(result));
12732 return resultobj;
12733 fail:
12734 return NULL;
12735 }
12736
12737
12738 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12739 PyObject *resultobj = 0;
12740 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12741 double arg2 ;
12742 void *argp1 = 0 ;
12743 int res1 = 0 ;
12744 double val2 ;
12745 int ecode2 = 0 ;
12746 PyObject *swig_obj[2] ;
12747
12748 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12750 if (!SWIG_IsOK(res1)) {
12751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12752 }
12753 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12754 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12755 if (!SWIG_IsOK(ecode2)) {
12756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12757 }
12758 arg2 = static_cast< double >(val2);
12759 if (arg1) (arg1)->saturation = arg2;
12760
12761 resultobj = SWIG_Py_Void();
12762 return resultobj;
12763 fail:
12764 return NULL;
12765 }
12766
12767
12768 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12769 PyObject *resultobj = 0;
12770 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12771 double result;
12772 void *argp1 = 0 ;
12773 int res1 = 0 ;
12774 PyObject *swig_obj[1] ;
12775
12776 if (!args) SWIG_fail;
12777 swig_obj[0] = args;
12778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12779 if (!SWIG_IsOK(res1)) {
12780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12781 }
12782 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12783 result = (double) ((arg1)->saturation);
12784 resultobj = SWIG_From_double(static_cast< double >(result));
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12792 PyObject *resultobj = 0;
12793 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12794 double arg2 ;
12795 void *argp1 = 0 ;
12796 int res1 = 0 ;
12797 double val2 ;
12798 int ecode2 = 0 ;
12799 PyObject *swig_obj[2] ;
12800
12801 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12803 if (!SWIG_IsOK(res1)) {
12804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12805 }
12806 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12807 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12808 if (!SWIG_IsOK(ecode2)) {
12809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12810 }
12811 arg2 = static_cast< double >(val2);
12812 if (arg1) (arg1)->value = arg2;
12813
12814 resultobj = SWIG_Py_Void();
12815 return resultobj;
12816 fail:
12817 return NULL;
12818 }
12819
12820
12821 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12822 PyObject *resultobj = 0;
12823 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12824 double result;
12825 void *argp1 = 0 ;
12826 int res1 = 0 ;
12827 PyObject *swig_obj[1] ;
12828
12829 if (!args) SWIG_fail;
12830 swig_obj[0] = args;
12831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12832 if (!SWIG_IsOK(res1)) {
12833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12834 }
12835 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12836 result = (double) ((arg1)->value);
12837 resultobj = SWIG_From_double(static_cast< double >(result));
12838 return resultobj;
12839 fail:
12840 return NULL;
12841 }
12842
12843
12844 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12845 PyObject *obj;
12846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12847 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12848 return SWIG_Py_Void();
12849 }
12850
12851 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12852 return SWIG_Python_InitShadowInstance(args);
12853 }
12854
12855 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12856 PyObject *resultobj = 0;
12857 wxString *arg1 = 0 ;
12858 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12859 int arg3 = (int) -1 ;
12860 wxImage *result = 0 ;
12861 bool temp1 = false ;
12862 long val2 ;
12863 int ecode2 = 0 ;
12864 int val3 ;
12865 int ecode3 = 0 ;
12866 PyObject * obj0 = 0 ;
12867 PyObject * obj1 = 0 ;
12868 PyObject * obj2 = 0 ;
12869 char * kwnames[] = {
12870 (char *) "name",(char *) "type",(char *) "index", NULL
12871 };
12872
12873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12874 {
12875 arg1 = wxString_in_helper(obj0);
12876 if (arg1 == NULL) SWIG_fail;
12877 temp1 = true;
12878 }
12879 if (obj1) {
12880 ecode2 = SWIG_AsVal_long(obj1, &val2);
12881 if (!SWIG_IsOK(ecode2)) {
12882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12883 }
12884 arg2 = static_cast< long >(val2);
12885 }
12886 if (obj2) {
12887 ecode3 = SWIG_AsVal_int(obj2, &val3);
12888 if (!SWIG_IsOK(ecode3)) {
12889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12890 }
12891 arg3 = static_cast< int >(val3);
12892 }
12893 {
12894 PyThreadState* __tstate = wxPyBeginAllowThreads();
12895 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12896 wxPyEndAllowThreads(__tstate);
12897 if (PyErr_Occurred()) SWIG_fail;
12898 }
12899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12900 {
12901 if (temp1)
12902 delete arg1;
12903 }
12904 return resultobj;
12905 fail:
12906 {
12907 if (temp1)
12908 delete arg1;
12909 }
12910 return NULL;
12911 }
12912
12913
12914 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12915 PyObject *resultobj = 0;
12916 wxImage *arg1 = (wxImage *) 0 ;
12917 void *argp1 = 0 ;
12918 int res1 = 0 ;
12919 PyObject *swig_obj[1] ;
12920
12921 if (!args) SWIG_fail;
12922 swig_obj[0] = args;
12923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12924 if (!SWIG_IsOK(res1)) {
12925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12926 }
12927 arg1 = reinterpret_cast< wxImage * >(argp1);
12928 {
12929 PyThreadState* __tstate = wxPyBeginAllowThreads();
12930 delete arg1;
12931
12932 wxPyEndAllowThreads(__tstate);
12933 if (PyErr_Occurred()) SWIG_fail;
12934 }
12935 resultobj = SWIG_Py_Void();
12936 return resultobj;
12937 fail:
12938 return NULL;
12939 }
12940
12941
12942 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12943 PyObject *resultobj = 0;
12944 wxString *arg1 = 0 ;
12945 wxString *arg2 = 0 ;
12946 int arg3 = (int) -1 ;
12947 wxImage *result = 0 ;
12948 bool temp1 = false ;
12949 bool temp2 = false ;
12950 int val3 ;
12951 int ecode3 = 0 ;
12952 PyObject * obj0 = 0 ;
12953 PyObject * obj1 = 0 ;
12954 PyObject * obj2 = 0 ;
12955 char * kwnames[] = {
12956 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12957 };
12958
12959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12960 {
12961 arg1 = wxString_in_helper(obj0);
12962 if (arg1 == NULL) SWIG_fail;
12963 temp1 = true;
12964 }
12965 {
12966 arg2 = wxString_in_helper(obj1);
12967 if (arg2 == NULL) SWIG_fail;
12968 temp2 = true;
12969 }
12970 if (obj2) {
12971 ecode3 = SWIG_AsVal_int(obj2, &val3);
12972 if (!SWIG_IsOK(ecode3)) {
12973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12974 }
12975 arg3 = static_cast< int >(val3);
12976 }
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12984 {
12985 if (temp1)
12986 delete arg1;
12987 }
12988 {
12989 if (temp2)
12990 delete arg2;
12991 }
12992 return resultobj;
12993 fail:
12994 {
12995 if (temp1)
12996 delete arg1;
12997 }
12998 {
12999 if (temp2)
13000 delete arg2;
13001 }
13002 return NULL;
13003 }
13004
13005
13006 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj = 0;
13008 wxInputStream *arg1 = 0 ;
13009 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13010 int arg3 = (int) -1 ;
13011 wxImage *result = 0 ;
13012 wxPyInputStream *temp1 ;
13013 bool created1 ;
13014 long val2 ;
13015 int ecode2 = 0 ;
13016 int val3 ;
13017 int ecode3 = 0 ;
13018 PyObject * obj0 = 0 ;
13019 PyObject * obj1 = 0 ;
13020 PyObject * obj2 = 0 ;
13021 char * kwnames[] = {
13022 (char *) "stream",(char *) "type",(char *) "index", NULL
13023 };
13024
13025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13026 {
13027 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13028 arg1 = temp1->m_wxis;
13029 created1 = false;
13030 } else {
13031 PyErr_Clear(); // clear the failure of the wxPyConvert above
13032 arg1 = wxPyCBInputStream_create(obj0, false);
13033 if (arg1 == NULL) {
13034 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13035 SWIG_fail;
13036 }
13037 created1 = true;
13038 }
13039 }
13040 if (obj1) {
13041 ecode2 = SWIG_AsVal_long(obj1, &val2);
13042 if (!SWIG_IsOK(ecode2)) {
13043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13044 }
13045 arg2 = static_cast< long >(val2);
13046 }
13047 if (obj2) {
13048 ecode3 = SWIG_AsVal_int(obj2, &val3);
13049 if (!SWIG_IsOK(ecode3)) {
13050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13051 }
13052 arg3 = static_cast< int >(val3);
13053 }
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13061 {
13062 if (created1) delete arg1;
13063 }
13064 return resultobj;
13065 fail:
13066 {
13067 if (created1) delete arg1;
13068 }
13069 return NULL;
13070 }
13071
13072
13073 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13074 PyObject *resultobj = 0;
13075 wxInputStream *arg1 = 0 ;
13076 wxString *arg2 = 0 ;
13077 int arg3 = (int) -1 ;
13078 wxImage *result = 0 ;
13079 wxPyInputStream *temp1 ;
13080 bool created1 ;
13081 bool temp2 = false ;
13082 int val3 ;
13083 int ecode3 = 0 ;
13084 PyObject * obj0 = 0 ;
13085 PyObject * obj1 = 0 ;
13086 PyObject * obj2 = 0 ;
13087 char * kwnames[] = {
13088 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13089 };
13090
13091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13092 {
13093 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13094 arg1 = temp1->m_wxis;
13095 created1 = false;
13096 } else {
13097 PyErr_Clear(); // clear the failure of the wxPyConvert above
13098 arg1 = wxPyCBInputStream_create(obj0, false);
13099 if (arg1 == NULL) {
13100 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13101 SWIG_fail;
13102 }
13103 created1 = true;
13104 }
13105 }
13106 {
13107 arg2 = wxString_in_helper(obj1);
13108 if (arg2 == NULL) SWIG_fail;
13109 temp2 = true;
13110 }
13111 if (obj2) {
13112 ecode3 = SWIG_AsVal_int(obj2, &val3);
13113 if (!SWIG_IsOK(ecode3)) {
13114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13115 }
13116 arg3 = static_cast< int >(val3);
13117 }
13118 {
13119 PyThreadState* __tstate = wxPyBeginAllowThreads();
13120 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13121 wxPyEndAllowThreads(__tstate);
13122 if (PyErr_Occurred()) SWIG_fail;
13123 }
13124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13125 {
13126 if (created1) delete arg1;
13127 }
13128 {
13129 if (temp2)
13130 delete arg2;
13131 }
13132 return resultobj;
13133 fail:
13134 {
13135 if (created1) delete arg1;
13136 }
13137 {
13138 if (temp2)
13139 delete arg2;
13140 }
13141 return NULL;
13142 }
13143
13144
13145 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj = 0;
13147 int arg1 = (int) 0 ;
13148 int arg2 = (int) 0 ;
13149 bool arg3 = (bool) true ;
13150 wxImage *result = 0 ;
13151 int val1 ;
13152 int ecode1 = 0 ;
13153 int val2 ;
13154 int ecode2 = 0 ;
13155 bool val3 ;
13156 int ecode3 = 0 ;
13157 PyObject * obj0 = 0 ;
13158 PyObject * obj1 = 0 ;
13159 PyObject * obj2 = 0 ;
13160 char * kwnames[] = {
13161 (char *) "width",(char *) "height",(char *) "clear", NULL
13162 };
13163
13164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13165 if (obj0) {
13166 ecode1 = SWIG_AsVal_int(obj0, &val1);
13167 if (!SWIG_IsOK(ecode1)) {
13168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13169 }
13170 arg1 = static_cast< int >(val1);
13171 }
13172 if (obj1) {
13173 ecode2 = SWIG_AsVal_int(obj1, &val2);
13174 if (!SWIG_IsOK(ecode2)) {
13175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13176 }
13177 arg2 = static_cast< int >(val2);
13178 }
13179 if (obj2) {
13180 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13181 if (!SWIG_IsOK(ecode3)) {
13182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13183 }
13184 arg3 = static_cast< bool >(val3);
13185 }
13186 {
13187 PyThreadState* __tstate = wxPyBeginAllowThreads();
13188 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13189 wxPyEndAllowThreads(__tstate);
13190 if (PyErr_Occurred()) SWIG_fail;
13191 }
13192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13193 return resultobj;
13194 fail:
13195 return NULL;
13196 }
13197
13198
13199 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13200 PyObject *resultobj = 0;
13201 wxBitmap *arg1 = 0 ;
13202 wxImage *result = 0 ;
13203 void *argp1 = 0 ;
13204 int res1 = 0 ;
13205 PyObject * obj0 = 0 ;
13206 char * kwnames[] = {
13207 (char *) "bitmap", NULL
13208 };
13209
13210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13211 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13212 if (!SWIG_IsOK(res1)) {
13213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13214 }
13215 if (!argp1) {
13216 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13217 }
13218 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13219 {
13220 if (!wxPyCheckForApp()) SWIG_fail;
13221 PyThreadState* __tstate = wxPyBeginAllowThreads();
13222 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj = 0;
13235 int arg1 ;
13236 int arg2 ;
13237 buffer arg3 ;
13238 int arg4 ;
13239 wxImage *result = 0 ;
13240 int val1 ;
13241 int ecode1 = 0 ;
13242 int val2 ;
13243 int ecode2 = 0 ;
13244 PyObject * obj0 = 0 ;
13245 PyObject * obj1 = 0 ;
13246 PyObject * obj2 = 0 ;
13247 char * kwnames[] = {
13248 (char *) "width",(char *) "height",(char *) "data", NULL
13249 };
13250
13251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13252 ecode1 = SWIG_AsVal_int(obj0, &val1);
13253 if (!SWIG_IsOK(ecode1)) {
13254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13255 }
13256 arg1 = static_cast< int >(val1);
13257 ecode2 = SWIG_AsVal_int(obj1, &val2);
13258 if (!SWIG_IsOK(ecode2)) {
13259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13260 }
13261 arg2 = static_cast< int >(val2);
13262 {
13263 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13264 }
13265 {
13266 PyThreadState* __tstate = wxPyBeginAllowThreads();
13267 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13268 wxPyEndAllowThreads(__tstate);
13269 if (PyErr_Occurred()) SWIG_fail;
13270 }
13271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13272 return resultobj;
13273 fail:
13274 return NULL;
13275 }
13276
13277
13278 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13279 PyObject *resultobj = 0;
13280 int arg1 ;
13281 int arg2 ;
13282 buffer arg3 ;
13283 int arg4 ;
13284 buffer arg5 ;
13285 int arg6 ;
13286 wxImage *result = 0 ;
13287 int val1 ;
13288 int ecode1 = 0 ;
13289 int val2 ;
13290 int ecode2 = 0 ;
13291 PyObject * obj0 = 0 ;
13292 PyObject * obj1 = 0 ;
13293 PyObject * obj2 = 0 ;
13294 PyObject * obj3 = 0 ;
13295 char * kwnames[] = {
13296 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13297 };
13298
13299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13300 ecode1 = SWIG_AsVal_int(obj0, &val1);
13301 if (!SWIG_IsOK(ecode1)) {
13302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13303 }
13304 arg1 = static_cast< int >(val1);
13305 ecode2 = SWIG_AsVal_int(obj1, &val2);
13306 if (!SWIG_IsOK(ecode2)) {
13307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13308 }
13309 arg2 = static_cast< int >(val2);
13310 {
13311 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13312 }
13313 {
13314 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13315 }
13316 {
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj = 0;
13331 wxImage *arg1 = (wxImage *) 0 ;
13332 int arg2 ;
13333 int arg3 ;
13334 bool arg4 = (bool) true ;
13335 void *argp1 = 0 ;
13336 int res1 = 0 ;
13337 int val2 ;
13338 int ecode2 = 0 ;
13339 int val3 ;
13340 int ecode3 = 0 ;
13341 bool val4 ;
13342 int ecode4 = 0 ;
13343 PyObject * obj0 = 0 ;
13344 PyObject * obj1 = 0 ;
13345 PyObject * obj2 = 0 ;
13346 PyObject * obj3 = 0 ;
13347 char * kwnames[] = {
13348 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13349 };
13350
13351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13353 if (!SWIG_IsOK(res1)) {
13354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13355 }
13356 arg1 = reinterpret_cast< wxImage * >(argp1);
13357 ecode2 = SWIG_AsVal_int(obj1, &val2);
13358 if (!SWIG_IsOK(ecode2)) {
13359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13360 }
13361 arg2 = static_cast< int >(val2);
13362 ecode3 = SWIG_AsVal_int(obj2, &val3);
13363 if (!SWIG_IsOK(ecode3)) {
13364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13365 }
13366 arg3 = static_cast< int >(val3);
13367 if (obj3) {
13368 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13369 if (!SWIG_IsOK(ecode4)) {
13370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13371 }
13372 arg4 = static_cast< bool >(val4);
13373 }
13374 {
13375 PyThreadState* __tstate = wxPyBeginAllowThreads();
13376 (arg1)->Create(arg2,arg3,arg4);
13377 wxPyEndAllowThreads(__tstate);
13378 if (PyErr_Occurred()) SWIG_fail;
13379 }
13380 resultobj = SWIG_Py_Void();
13381 return resultobj;
13382 fail:
13383 return NULL;
13384 }
13385
13386
13387 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13388 PyObject *resultobj = 0;
13389 wxImage *arg1 = (wxImage *) 0 ;
13390 void *argp1 = 0 ;
13391 int res1 = 0 ;
13392 PyObject *swig_obj[1] ;
13393
13394 if (!args) SWIG_fail;
13395 swig_obj[0] = args;
13396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13397 if (!SWIG_IsOK(res1)) {
13398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13399 }
13400 arg1 = reinterpret_cast< wxImage * >(argp1);
13401 {
13402 PyThreadState* __tstate = wxPyBeginAllowThreads();
13403 (arg1)->Destroy();
13404 wxPyEndAllowThreads(__tstate);
13405 if (PyErr_Occurred()) SWIG_fail;
13406 }
13407 resultobj = SWIG_Py_Void();
13408 return resultobj;
13409 fail:
13410 return NULL;
13411 }
13412
13413
13414 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13415 PyObject *resultobj = 0;
13416 wxImage *arg1 = (wxImage *) 0 ;
13417 int arg2 ;
13418 int arg3 ;
13419 SwigValueWrapper<wxImage > result;
13420 void *argp1 = 0 ;
13421 int res1 = 0 ;
13422 int val2 ;
13423 int ecode2 = 0 ;
13424 int val3 ;
13425 int ecode3 = 0 ;
13426 PyObject * obj0 = 0 ;
13427 PyObject * obj1 = 0 ;
13428 PyObject * obj2 = 0 ;
13429 char * kwnames[] = {
13430 (char *) "self",(char *) "width",(char *) "height", NULL
13431 };
13432
13433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13435 if (!SWIG_IsOK(res1)) {
13436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13437 }
13438 arg1 = reinterpret_cast< wxImage * >(argp1);
13439 ecode2 = SWIG_AsVal_int(obj1, &val2);
13440 if (!SWIG_IsOK(ecode2)) {
13441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13442 }
13443 arg2 = static_cast< int >(val2);
13444 ecode3 = SWIG_AsVal_int(obj2, &val3);
13445 if (!SWIG_IsOK(ecode3)) {
13446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13447 }
13448 arg3 = static_cast< int >(val3);
13449 {
13450 PyThreadState* __tstate = wxPyBeginAllowThreads();
13451 result = (arg1)->Scale(arg2,arg3);
13452 wxPyEndAllowThreads(__tstate);
13453 if (PyErr_Occurred()) SWIG_fail;
13454 }
13455 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13456 return resultobj;
13457 fail:
13458 return NULL;
13459 }
13460
13461
13462 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj = 0;
13464 wxImage *arg1 = (wxImage *) 0 ;
13465 int arg2 ;
13466 int arg3 ;
13467 SwigValueWrapper<wxImage > result;
13468 void *argp1 = 0 ;
13469 int res1 = 0 ;
13470 int val2 ;
13471 int ecode2 = 0 ;
13472 int val3 ;
13473 int ecode3 = 0 ;
13474 PyObject * obj0 = 0 ;
13475 PyObject * obj1 = 0 ;
13476 PyObject * obj2 = 0 ;
13477 char * kwnames[] = {
13478 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13479 };
13480
13481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13483 if (!SWIG_IsOK(res1)) {
13484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13485 }
13486 arg1 = reinterpret_cast< wxImage * >(argp1);
13487 ecode2 = SWIG_AsVal_int(obj1, &val2);
13488 if (!SWIG_IsOK(ecode2)) {
13489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13490 }
13491 arg2 = static_cast< int >(val2);
13492 ecode3 = SWIG_AsVal_int(obj2, &val3);
13493 if (!SWIG_IsOK(ecode3)) {
13494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13495 }
13496 arg3 = static_cast< int >(val3);
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13504 return resultobj;
13505 fail:
13506 return NULL;
13507 }
13508
13509
13510 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj = 0;
13512 wxImage *arg1 = (wxImage *) 0 ;
13513 int arg2 ;
13514 int arg3 ;
13515 wxImage *result = 0 ;
13516 void *argp1 = 0 ;
13517 int res1 = 0 ;
13518 int val2 ;
13519 int ecode2 = 0 ;
13520 int val3 ;
13521 int ecode3 = 0 ;
13522 PyObject * obj0 = 0 ;
13523 PyObject * obj1 = 0 ;
13524 PyObject * obj2 = 0 ;
13525 char * kwnames[] = {
13526 (char *) "self",(char *) "width",(char *) "height", NULL
13527 };
13528
13529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13531 if (!SWIG_IsOK(res1)) {
13532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13533 }
13534 arg1 = reinterpret_cast< wxImage * >(argp1);
13535 ecode2 = SWIG_AsVal_int(obj1, &val2);
13536 if (!SWIG_IsOK(ecode2)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13538 }
13539 arg2 = static_cast< int >(val2);
13540 ecode3 = SWIG_AsVal_int(obj2, &val3);
13541 if (!SWIG_IsOK(ecode3)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13543 }
13544 arg3 = static_cast< int >(val3);
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 {
13548 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13549 result = (wxImage *) &_result_ref;
13550 }
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13555 return resultobj;
13556 fail:
13557 return NULL;
13558 }
13559
13560
13561 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13562 PyObject *resultobj = 0;
13563 wxImage *arg1 = (wxImage *) 0 ;
13564 wxSize *arg2 = 0 ;
13565 wxPoint *arg3 = 0 ;
13566 int arg4 = (int) -1 ;
13567 int arg5 = (int) -1 ;
13568 int arg6 = (int) -1 ;
13569 wxImage *result = 0 ;
13570 void *argp1 = 0 ;
13571 int res1 = 0 ;
13572 wxSize temp2 ;
13573 wxPoint temp3 ;
13574 int val4 ;
13575 int ecode4 = 0 ;
13576 int val5 ;
13577 int ecode5 = 0 ;
13578 int val6 ;
13579 int ecode6 = 0 ;
13580 PyObject * obj0 = 0 ;
13581 PyObject * obj1 = 0 ;
13582 PyObject * obj2 = 0 ;
13583 PyObject * obj3 = 0 ;
13584 PyObject * obj4 = 0 ;
13585 PyObject * obj5 = 0 ;
13586 char * kwnames[] = {
13587 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13588 };
13589
13590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13592 if (!SWIG_IsOK(res1)) {
13593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13594 }
13595 arg1 = reinterpret_cast< wxImage * >(argp1);
13596 {
13597 arg2 = &temp2;
13598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13599 }
13600 {
13601 arg3 = &temp3;
13602 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13603 }
13604 if (obj3) {
13605 ecode4 = SWIG_AsVal_int(obj3, &val4);
13606 if (!SWIG_IsOK(ecode4)) {
13607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13608 }
13609 arg4 = static_cast< int >(val4);
13610 }
13611 if (obj4) {
13612 ecode5 = SWIG_AsVal_int(obj4, &val5);
13613 if (!SWIG_IsOK(ecode5)) {
13614 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13615 }
13616 arg5 = static_cast< int >(val5);
13617 }
13618 if (obj5) {
13619 ecode6 = SWIG_AsVal_int(obj5, &val6);
13620 if (!SWIG_IsOK(ecode6)) {
13621 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13622 }
13623 arg6 = static_cast< int >(val6);
13624 }
13625 {
13626 PyThreadState* __tstate = wxPyBeginAllowThreads();
13627 {
13628 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13629 result = (wxImage *) &_result_ref;
13630 }
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13635 return resultobj;
13636 fail:
13637 return NULL;
13638 }
13639
13640
13641 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13642 PyObject *resultobj = 0;
13643 wxImage *arg1 = (wxImage *) 0 ;
13644 int arg2 ;
13645 int arg3 ;
13646 byte arg4 ;
13647 byte arg5 ;
13648 byte arg6 ;
13649 void *argp1 = 0 ;
13650 int res1 = 0 ;
13651 int val2 ;
13652 int ecode2 = 0 ;
13653 int val3 ;
13654 int ecode3 = 0 ;
13655 unsigned char val4 ;
13656 int ecode4 = 0 ;
13657 unsigned char val5 ;
13658 int ecode5 = 0 ;
13659 unsigned char val6 ;
13660 int ecode6 = 0 ;
13661 PyObject * obj0 = 0 ;
13662 PyObject * obj1 = 0 ;
13663 PyObject * obj2 = 0 ;
13664 PyObject * obj3 = 0 ;
13665 PyObject * obj4 = 0 ;
13666 PyObject * obj5 = 0 ;
13667 char * kwnames[] = {
13668 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13669 };
13670
13671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13673 if (!SWIG_IsOK(res1)) {
13674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13675 }
13676 arg1 = reinterpret_cast< wxImage * >(argp1);
13677 ecode2 = SWIG_AsVal_int(obj1, &val2);
13678 if (!SWIG_IsOK(ecode2)) {
13679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13680 }
13681 arg2 = static_cast< int >(val2);
13682 ecode3 = SWIG_AsVal_int(obj2, &val3);
13683 if (!SWIG_IsOK(ecode3)) {
13684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13685 }
13686 arg3 = static_cast< int >(val3);
13687 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13688 if (!SWIG_IsOK(ecode4)) {
13689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13690 }
13691 arg4 = static_cast< byte >(val4);
13692 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13693 if (!SWIG_IsOK(ecode5)) {
13694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13695 }
13696 arg5 = static_cast< byte >(val5);
13697 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13698 if (!SWIG_IsOK(ecode6)) {
13699 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13700 }
13701 arg6 = static_cast< byte >(val6);
13702 {
13703 PyThreadState* __tstate = wxPyBeginAllowThreads();
13704 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 resultobj = SWIG_Py_Void();
13709 return resultobj;
13710 fail:
13711 return NULL;
13712 }
13713
13714
13715 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj = 0;
13717 wxImage *arg1 = (wxImage *) 0 ;
13718 wxRect *arg2 = 0 ;
13719 byte arg3 ;
13720 byte arg4 ;
13721 byte arg5 ;
13722 void *argp1 = 0 ;
13723 int res1 = 0 ;
13724 wxRect temp2 ;
13725 unsigned char val3 ;
13726 int ecode3 = 0 ;
13727 unsigned char val4 ;
13728 int ecode4 = 0 ;
13729 unsigned char val5 ;
13730 int ecode5 = 0 ;
13731 PyObject * obj0 = 0 ;
13732 PyObject * obj1 = 0 ;
13733 PyObject * obj2 = 0 ;
13734 PyObject * obj3 = 0 ;
13735 PyObject * obj4 = 0 ;
13736 char * kwnames[] = {
13737 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13738 };
13739
13740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13742 if (!SWIG_IsOK(res1)) {
13743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13744 }
13745 arg1 = reinterpret_cast< wxImage * >(argp1);
13746 {
13747 arg2 = &temp2;
13748 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13749 }
13750 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13751 if (!SWIG_IsOK(ecode3)) {
13752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13753 }
13754 arg3 = static_cast< byte >(val3);
13755 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13756 if (!SWIG_IsOK(ecode4)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13758 }
13759 arg4 = static_cast< byte >(val4);
13760 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13761 if (!SWIG_IsOK(ecode5)) {
13762 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13763 }
13764 arg5 = static_cast< byte >(val5);
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 resultobj = SWIG_Py_Void();
13772 return resultobj;
13773 fail:
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj = 0;
13780 wxImage *arg1 = (wxImage *) 0 ;
13781 int arg2 ;
13782 int arg3 ;
13783 byte result;
13784 void *argp1 = 0 ;
13785 int res1 = 0 ;
13786 int val2 ;
13787 int ecode2 = 0 ;
13788 int val3 ;
13789 int ecode3 = 0 ;
13790 PyObject * obj0 = 0 ;
13791 PyObject * obj1 = 0 ;
13792 PyObject * obj2 = 0 ;
13793 char * kwnames[] = {
13794 (char *) "self",(char *) "x",(char *) "y", NULL
13795 };
13796
13797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13799 if (!SWIG_IsOK(res1)) {
13800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13801 }
13802 arg1 = reinterpret_cast< wxImage * >(argp1);
13803 ecode2 = SWIG_AsVal_int(obj1, &val2);
13804 if (!SWIG_IsOK(ecode2)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13806 }
13807 arg2 = static_cast< int >(val2);
13808 ecode3 = SWIG_AsVal_int(obj2, &val3);
13809 if (!SWIG_IsOK(ecode3)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13811 }
13812 arg3 = static_cast< int >(val3);
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (byte)(arg1)->GetRed(arg2,arg3);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxImage *arg1 = (wxImage *) 0 ;
13829 int arg2 ;
13830 int arg3 ;
13831 byte result;
13832 void *argp1 = 0 ;
13833 int res1 = 0 ;
13834 int val2 ;
13835 int ecode2 = 0 ;
13836 int val3 ;
13837 int ecode3 = 0 ;
13838 PyObject * obj0 = 0 ;
13839 PyObject * obj1 = 0 ;
13840 PyObject * obj2 = 0 ;
13841 char * kwnames[] = {
13842 (char *) "self",(char *) "x",(char *) "y", NULL
13843 };
13844
13845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13847 if (!SWIG_IsOK(res1)) {
13848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13849 }
13850 arg1 = reinterpret_cast< wxImage * >(argp1);
13851 ecode2 = SWIG_AsVal_int(obj1, &val2);
13852 if (!SWIG_IsOK(ecode2)) {
13853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13854 }
13855 arg2 = static_cast< int >(val2);
13856 ecode3 = SWIG_AsVal_int(obj2, &val3);
13857 if (!SWIG_IsOK(ecode3)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13859 }
13860 arg3 = static_cast< int >(val3);
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 result = (byte)(arg1)->GetGreen(arg2,arg3);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 wxImage *arg1 = (wxImage *) 0 ;
13877 int arg2 ;
13878 int arg3 ;
13879 byte result;
13880 void *argp1 = 0 ;
13881 int res1 = 0 ;
13882 int val2 ;
13883 int ecode2 = 0 ;
13884 int val3 ;
13885 int ecode3 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "self",(char *) "x",(char *) "y", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13895 if (!SWIG_IsOK(res1)) {
13896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13897 }
13898 arg1 = reinterpret_cast< wxImage * >(argp1);
13899 ecode2 = SWIG_AsVal_int(obj1, &val2);
13900 if (!SWIG_IsOK(ecode2)) {
13901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13902 }
13903 arg2 = static_cast< int >(val2);
13904 ecode3 = SWIG_AsVal_int(obj2, &val3);
13905 if (!SWIG_IsOK(ecode3)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13907 }
13908 arg3 = static_cast< int >(val3);
13909 {
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 result = (byte)(arg1)->GetBlue(arg2,arg3);
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13923 PyObject *resultobj = 0;
13924 wxImage *arg1 = (wxImage *) 0 ;
13925 int arg2 ;
13926 int arg3 ;
13927 byte arg4 ;
13928 void *argp1 = 0 ;
13929 int res1 = 0 ;
13930 int val2 ;
13931 int ecode2 = 0 ;
13932 int val3 ;
13933 int ecode3 = 0 ;
13934 unsigned char val4 ;
13935 int ecode4 = 0 ;
13936 PyObject * obj0 = 0 ;
13937 PyObject * obj1 = 0 ;
13938 PyObject * obj2 = 0 ;
13939 PyObject * obj3 = 0 ;
13940 char * kwnames[] = {
13941 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13942 };
13943
13944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13946 if (!SWIG_IsOK(res1)) {
13947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13948 }
13949 arg1 = reinterpret_cast< wxImage * >(argp1);
13950 ecode2 = SWIG_AsVal_int(obj1, &val2);
13951 if (!SWIG_IsOK(ecode2)) {
13952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13953 }
13954 arg2 = static_cast< int >(val2);
13955 ecode3 = SWIG_AsVal_int(obj2, &val3);
13956 if (!SWIG_IsOK(ecode3)) {
13957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13958 }
13959 arg3 = static_cast< int >(val3);
13960 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13961 if (!SWIG_IsOK(ecode4)) {
13962 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13963 }
13964 arg4 = static_cast< byte >(val4);
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 (arg1)->SetAlpha(arg2,arg3,arg4);
13968 wxPyEndAllowThreads(__tstate);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 }
13971 resultobj = SWIG_Py_Void();
13972 return resultobj;
13973 fail:
13974 return NULL;
13975 }
13976
13977
13978 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13979 PyObject *resultobj = 0;
13980 wxImage *arg1 = (wxImage *) 0 ;
13981 int arg2 ;
13982 int arg3 ;
13983 byte result;
13984 void *argp1 = 0 ;
13985 int res1 = 0 ;
13986 int val2 ;
13987 int ecode2 = 0 ;
13988 int val3 ;
13989 int ecode3 = 0 ;
13990 PyObject * obj0 = 0 ;
13991 PyObject * obj1 = 0 ;
13992 PyObject * obj2 = 0 ;
13993 char * kwnames[] = {
13994 (char *) "self",(char *) "x",(char *) "y", NULL
13995 };
13996
13997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13999 if (!SWIG_IsOK(res1)) {
14000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14001 }
14002 arg1 = reinterpret_cast< wxImage * >(argp1);
14003 ecode2 = SWIG_AsVal_int(obj1, &val2);
14004 if (!SWIG_IsOK(ecode2)) {
14005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14006 }
14007 arg2 = static_cast< int >(val2);
14008 ecode3 = SWIG_AsVal_int(obj2, &val3);
14009 if (!SWIG_IsOK(ecode3)) {
14010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14011 }
14012 arg3 = static_cast< int >(val3);
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14020 return resultobj;
14021 fail:
14022 return NULL;
14023 }
14024
14025
14026 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14027 PyObject *resultobj = 0;
14028 wxImage *arg1 = (wxImage *) 0 ;
14029 bool result;
14030 void *argp1 = 0 ;
14031 int res1 = 0 ;
14032 PyObject *swig_obj[1] ;
14033
14034 if (!args) SWIG_fail;
14035 swig_obj[0] = args;
14036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14037 if (!SWIG_IsOK(res1)) {
14038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14039 }
14040 arg1 = reinterpret_cast< wxImage * >(argp1);
14041 {
14042 PyThreadState* __tstate = wxPyBeginAllowThreads();
14043 result = (bool)(arg1)->HasAlpha();
14044 wxPyEndAllowThreads(__tstate);
14045 if (PyErr_Occurred()) SWIG_fail;
14046 }
14047 {
14048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14049 }
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14057 PyObject *resultobj = 0;
14058 wxImage *arg1 = (wxImage *) 0 ;
14059 void *argp1 = 0 ;
14060 int res1 = 0 ;
14061 PyObject *swig_obj[1] ;
14062
14063 if (!args) SWIG_fail;
14064 swig_obj[0] = args;
14065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14066 if (!SWIG_IsOK(res1)) {
14067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14068 }
14069 arg1 = reinterpret_cast< wxImage * >(argp1);
14070 {
14071 PyThreadState* __tstate = wxPyBeginAllowThreads();
14072 (arg1)->InitAlpha();
14073 wxPyEndAllowThreads(__tstate);
14074 if (PyErr_Occurred()) SWIG_fail;
14075 }
14076 resultobj = SWIG_Py_Void();
14077 return resultobj;
14078 fail:
14079 return NULL;
14080 }
14081
14082
14083 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14084 PyObject *resultobj = 0;
14085 wxImage *arg1 = (wxImage *) 0 ;
14086 int arg2 ;
14087 int arg3 ;
14088 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14089 bool result;
14090 void *argp1 = 0 ;
14091 int res1 = 0 ;
14092 int val2 ;
14093 int ecode2 = 0 ;
14094 int val3 ;
14095 int ecode3 = 0 ;
14096 unsigned char val4 ;
14097 int ecode4 = 0 ;
14098 PyObject * obj0 = 0 ;
14099 PyObject * obj1 = 0 ;
14100 PyObject * obj2 = 0 ;
14101 PyObject * obj3 = 0 ;
14102 char * kwnames[] = {
14103 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14104 };
14105
14106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14108 if (!SWIG_IsOK(res1)) {
14109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14110 }
14111 arg1 = reinterpret_cast< wxImage * >(argp1);
14112 ecode2 = SWIG_AsVal_int(obj1, &val2);
14113 if (!SWIG_IsOK(ecode2)) {
14114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14115 }
14116 arg2 = static_cast< int >(val2);
14117 ecode3 = SWIG_AsVal_int(obj2, &val3);
14118 if (!SWIG_IsOK(ecode3)) {
14119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14120 }
14121 arg3 = static_cast< int >(val3);
14122 if (obj3) {
14123 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14124 if (!SWIG_IsOK(ecode4)) {
14125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14126 }
14127 arg4 = static_cast< byte >(val4);
14128 }
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 {
14136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14137 }
14138 return resultobj;
14139 fail:
14140 return NULL;
14141 }
14142
14143
14144 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14145 PyObject *resultobj = 0;
14146 wxImage *arg1 = (wxImage *) 0 ;
14147 byte *arg2 = (byte *) 0 ;
14148 byte *arg3 = (byte *) 0 ;
14149 byte *arg4 = (byte *) 0 ;
14150 byte arg5 = (byte) 0 ;
14151 byte arg6 = (byte) 0 ;
14152 byte arg7 = (byte) 0 ;
14153 bool result;
14154 void *argp1 = 0 ;
14155 int res1 = 0 ;
14156 byte temp2 ;
14157 int res2 = SWIG_TMPOBJ ;
14158 byte temp3 ;
14159 int res3 = SWIG_TMPOBJ ;
14160 byte temp4 ;
14161 int res4 = SWIG_TMPOBJ ;
14162 unsigned char val5 ;
14163 int ecode5 = 0 ;
14164 unsigned char val6 ;
14165 int ecode6 = 0 ;
14166 unsigned char val7 ;
14167 int ecode7 = 0 ;
14168 PyObject * obj0 = 0 ;
14169 PyObject * obj1 = 0 ;
14170 PyObject * obj2 = 0 ;
14171 PyObject * obj3 = 0 ;
14172 char * kwnames[] = {
14173 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14174 };
14175
14176 arg2 = &temp2;
14177 arg3 = &temp3;
14178 arg4 = &temp4;
14179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14181 if (!SWIG_IsOK(res1)) {
14182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14183 }
14184 arg1 = reinterpret_cast< wxImage * >(argp1);
14185 if (obj1) {
14186 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14187 if (!SWIG_IsOK(ecode5)) {
14188 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14189 }
14190 arg5 = static_cast< byte >(val5);
14191 }
14192 if (obj2) {
14193 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14194 if (!SWIG_IsOK(ecode6)) {
14195 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14196 }
14197 arg6 = static_cast< byte >(val6);
14198 }
14199 if (obj3) {
14200 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14201 if (!SWIG_IsOK(ecode7)) {
14202 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14203 }
14204 arg7 = static_cast< byte >(val7);
14205 }
14206 {
14207 PyThreadState* __tstate = wxPyBeginAllowThreads();
14208 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14209 wxPyEndAllowThreads(__tstate);
14210 if (PyErr_Occurred()) SWIG_fail;
14211 }
14212 {
14213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14214 }
14215 if (SWIG_IsTmpObj(res2)) {
14216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14217 } else {
14218 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14220 }
14221 if (SWIG_IsTmpObj(res3)) {
14222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14223 } else {
14224 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14226 }
14227 if (SWIG_IsTmpObj(res4)) {
14228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14229 } else {
14230 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14232 }
14233 return resultobj;
14234 fail:
14235 return NULL;
14236 }
14237
14238
14239 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14240 PyObject *resultobj = 0;
14241 wxImage *arg1 = (wxImage *) 0 ;
14242 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14243 bool result;
14244 void *argp1 = 0 ;
14245 int res1 = 0 ;
14246 unsigned char val2 ;
14247 int ecode2 = 0 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 char * kwnames[] = {
14251 (char *) "self",(char *) "threshold", NULL
14252 };
14253
14254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14256 if (!SWIG_IsOK(res1)) {
14257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14258 }
14259 arg1 = reinterpret_cast< wxImage * >(argp1);
14260 if (obj1) {
14261 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14262 if (!SWIG_IsOK(ecode2)) {
14263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14264 }
14265 arg2 = static_cast< byte >(val2);
14266 }
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14270 wxPyEndAllowThreads(__tstate);
14271 if (PyErr_Occurred()) SWIG_fail;
14272 }
14273 {
14274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14275 }
14276 return resultobj;
14277 fail:
14278 return NULL;
14279 }
14280
14281
14282 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14283 PyObject *resultobj = 0;
14284 wxImage *arg1 = (wxImage *) 0 ;
14285 byte arg2 ;
14286 byte arg3 ;
14287 byte arg4 ;
14288 bool result;
14289 void *argp1 = 0 ;
14290 int res1 = 0 ;
14291 unsigned char val2 ;
14292 int ecode2 = 0 ;
14293 unsigned char val3 ;
14294 int ecode3 = 0 ;
14295 unsigned char val4 ;
14296 int ecode4 = 0 ;
14297 PyObject * obj0 = 0 ;
14298 PyObject * obj1 = 0 ;
14299 PyObject * obj2 = 0 ;
14300 PyObject * obj3 = 0 ;
14301 char * kwnames[] = {
14302 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14303 };
14304
14305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14307 if (!SWIG_IsOK(res1)) {
14308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14309 }
14310 arg1 = reinterpret_cast< wxImage * >(argp1);
14311 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14312 if (!SWIG_IsOK(ecode2)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14314 }
14315 arg2 = static_cast< byte >(val2);
14316 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14317 if (!SWIG_IsOK(ecode3)) {
14318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14319 }
14320 arg3 = static_cast< byte >(val3);
14321 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14322 if (!SWIG_IsOK(ecode4)) {
14323 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14324 }
14325 arg4 = static_cast< byte >(val4);
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 {
14333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14334 }
14335 return resultobj;
14336 fail:
14337 return NULL;
14338 }
14339
14340
14341 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj = 0;
14343 wxImage *arg1 = (wxImage *) 0 ;
14344 wxImage *arg2 = 0 ;
14345 byte arg3 ;
14346 byte arg4 ;
14347 byte arg5 ;
14348 bool result;
14349 void *argp1 = 0 ;
14350 int res1 = 0 ;
14351 void *argp2 = 0 ;
14352 int res2 = 0 ;
14353 unsigned char val3 ;
14354 int ecode3 = 0 ;
14355 unsigned char val4 ;
14356 int ecode4 = 0 ;
14357 unsigned char val5 ;
14358 int ecode5 = 0 ;
14359 PyObject * obj0 = 0 ;
14360 PyObject * obj1 = 0 ;
14361 PyObject * obj2 = 0 ;
14362 PyObject * obj3 = 0 ;
14363 PyObject * obj4 = 0 ;
14364 char * kwnames[] = {
14365 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14366 };
14367
14368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14370 if (!SWIG_IsOK(res1)) {
14371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14372 }
14373 arg1 = reinterpret_cast< wxImage * >(argp1);
14374 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14375 if (!SWIG_IsOK(res2)) {
14376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14377 }
14378 if (!argp2) {
14379 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14380 }
14381 arg2 = reinterpret_cast< wxImage * >(argp2);
14382 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14383 if (!SWIG_IsOK(ecode3)) {
14384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14385 }
14386 arg3 = static_cast< byte >(val3);
14387 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14388 if (!SWIG_IsOK(ecode4)) {
14389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14390 }
14391 arg4 = static_cast< byte >(val4);
14392 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14393 if (!SWIG_IsOK(ecode5)) {
14394 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14395 }
14396 arg5 = static_cast< byte >(val5);
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 {
14404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14405 }
14406 return resultobj;
14407 fail:
14408 return NULL;
14409 }
14410
14411
14412 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14413 PyObject *resultobj = 0;
14414 wxString *arg1 = 0 ;
14415 bool result;
14416 bool temp1 = false ;
14417 PyObject * obj0 = 0 ;
14418 char * kwnames[] = {
14419 (char *) "filename", NULL
14420 };
14421
14422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14423 {
14424 arg1 = wxString_in_helper(obj0);
14425 if (arg1 == NULL) SWIG_fail;
14426 temp1 = true;
14427 }
14428 {
14429 PyThreadState* __tstate = wxPyBeginAllowThreads();
14430 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14431 wxPyEndAllowThreads(__tstate);
14432 if (PyErr_Occurred()) SWIG_fail;
14433 }
14434 {
14435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14436 }
14437 {
14438 if (temp1)
14439 delete arg1;
14440 }
14441 return resultobj;
14442 fail:
14443 {
14444 if (temp1)
14445 delete arg1;
14446 }
14447 return NULL;
14448 }
14449
14450
14451 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14452 PyObject *resultobj = 0;
14453 wxString *arg1 = 0 ;
14454 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14455 int result;
14456 bool temp1 = false ;
14457 long val2 ;
14458 int ecode2 = 0 ;
14459 PyObject * obj0 = 0 ;
14460 PyObject * obj1 = 0 ;
14461 char * kwnames[] = {
14462 (char *) "filename",(char *) "type", NULL
14463 };
14464
14465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14466 {
14467 arg1 = wxString_in_helper(obj0);
14468 if (arg1 == NULL) SWIG_fail;
14469 temp1 = true;
14470 }
14471 if (obj1) {
14472 ecode2 = SWIG_AsVal_long(obj1, &val2);
14473 if (!SWIG_IsOK(ecode2)) {
14474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14475 }
14476 arg2 = static_cast< long >(val2);
14477 }
14478 {
14479 PyThreadState* __tstate = wxPyBeginAllowThreads();
14480 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14481 wxPyEndAllowThreads(__tstate);
14482 if (PyErr_Occurred()) SWIG_fail;
14483 }
14484 resultobj = SWIG_From_int(static_cast< int >(result));
14485 {
14486 if (temp1)
14487 delete arg1;
14488 }
14489 return resultobj;
14490 fail:
14491 {
14492 if (temp1)
14493 delete arg1;
14494 }
14495 return NULL;
14496 }
14497
14498
14499 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14500 PyObject *resultobj = 0;
14501 wxImage *arg1 = (wxImage *) 0 ;
14502 wxString *arg2 = 0 ;
14503 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14504 int arg4 = (int) -1 ;
14505 bool result;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 bool temp2 = false ;
14509 long val3 ;
14510 int ecode3 = 0 ;
14511 int val4 ;
14512 int ecode4 = 0 ;
14513 PyObject * obj0 = 0 ;
14514 PyObject * obj1 = 0 ;
14515 PyObject * obj2 = 0 ;
14516 PyObject * obj3 = 0 ;
14517 char * kwnames[] = {
14518 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14519 };
14520
14521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14523 if (!SWIG_IsOK(res1)) {
14524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14525 }
14526 arg1 = reinterpret_cast< wxImage * >(argp1);
14527 {
14528 arg2 = wxString_in_helper(obj1);
14529 if (arg2 == NULL) SWIG_fail;
14530 temp2 = true;
14531 }
14532 if (obj2) {
14533 ecode3 = SWIG_AsVal_long(obj2, &val3);
14534 if (!SWIG_IsOK(ecode3)) {
14535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14536 }
14537 arg3 = static_cast< long >(val3);
14538 }
14539 if (obj3) {
14540 ecode4 = SWIG_AsVal_int(obj3, &val4);
14541 if (!SWIG_IsOK(ecode4)) {
14542 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14543 }
14544 arg4 = static_cast< int >(val4);
14545 }
14546 {
14547 PyThreadState* __tstate = wxPyBeginAllowThreads();
14548 result = (bool)(arg1)->LoadFile((wxString const &)*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 {
14556 if (temp2)
14557 delete arg2;
14558 }
14559 return resultobj;
14560 fail:
14561 {
14562 if (temp2)
14563 delete arg2;
14564 }
14565 return NULL;
14566 }
14567
14568
14569 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14570 PyObject *resultobj = 0;
14571 wxImage *arg1 = (wxImage *) 0 ;
14572 wxString *arg2 = 0 ;
14573 wxString *arg3 = 0 ;
14574 int arg4 = (int) -1 ;
14575 bool result;
14576 void *argp1 = 0 ;
14577 int res1 = 0 ;
14578 bool temp2 = false ;
14579 bool temp3 = false ;
14580 int val4 ;
14581 int ecode4 = 0 ;
14582 PyObject * obj0 = 0 ;
14583 PyObject * obj1 = 0 ;
14584 PyObject * obj2 = 0 ;
14585 PyObject * obj3 = 0 ;
14586 char * kwnames[] = {
14587 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14588 };
14589
14590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14592 if (!SWIG_IsOK(res1)) {
14593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14594 }
14595 arg1 = reinterpret_cast< wxImage * >(argp1);
14596 {
14597 arg2 = wxString_in_helper(obj1);
14598 if (arg2 == NULL) SWIG_fail;
14599 temp2 = true;
14600 }
14601 {
14602 arg3 = wxString_in_helper(obj2);
14603 if (arg3 == NULL) SWIG_fail;
14604 temp3 = true;
14605 }
14606 if (obj3) {
14607 ecode4 = SWIG_AsVal_int(obj3, &val4);
14608 if (!SWIG_IsOK(ecode4)) {
14609 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14610 }
14611 arg4 = static_cast< int >(val4);
14612 }
14613 {
14614 PyThreadState* __tstate = wxPyBeginAllowThreads();
14615 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14616 wxPyEndAllowThreads(__tstate);
14617 if (PyErr_Occurred()) SWIG_fail;
14618 }
14619 {
14620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14621 }
14622 {
14623 if (temp2)
14624 delete arg2;
14625 }
14626 {
14627 if (temp3)
14628 delete arg3;
14629 }
14630 return resultobj;
14631 fail:
14632 {
14633 if (temp2)
14634 delete arg2;
14635 }
14636 {
14637 if (temp3)
14638 delete arg3;
14639 }
14640 return NULL;
14641 }
14642
14643
14644 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj = 0;
14646 wxImage *arg1 = (wxImage *) 0 ;
14647 wxString *arg2 = 0 ;
14648 int arg3 ;
14649 bool result;
14650 void *argp1 = 0 ;
14651 int res1 = 0 ;
14652 bool temp2 = false ;
14653 int val3 ;
14654 int ecode3 = 0 ;
14655 PyObject * obj0 = 0 ;
14656 PyObject * obj1 = 0 ;
14657 PyObject * obj2 = 0 ;
14658 char * kwnames[] = {
14659 (char *) "self",(char *) "name",(char *) "type", NULL
14660 };
14661
14662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14664 if (!SWIG_IsOK(res1)) {
14665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14666 }
14667 arg1 = reinterpret_cast< wxImage * >(argp1);
14668 {
14669 arg2 = wxString_in_helper(obj1);
14670 if (arg2 == NULL) SWIG_fail;
14671 temp2 = true;
14672 }
14673 ecode3 = SWIG_AsVal_int(obj2, &val3);
14674 if (!SWIG_IsOK(ecode3)) {
14675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14676 }
14677 arg3 = static_cast< int >(val3);
14678 {
14679 PyThreadState* __tstate = wxPyBeginAllowThreads();
14680 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 {
14685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14686 }
14687 {
14688 if (temp2)
14689 delete arg2;
14690 }
14691 return resultobj;
14692 fail:
14693 {
14694 if (temp2)
14695 delete arg2;
14696 }
14697 return NULL;
14698 }
14699
14700
14701 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj = 0;
14703 wxImage *arg1 = (wxImage *) 0 ;
14704 wxString *arg2 = 0 ;
14705 wxString *arg3 = 0 ;
14706 bool result;
14707 void *argp1 = 0 ;
14708 int res1 = 0 ;
14709 bool temp2 = false ;
14710 bool temp3 = false ;
14711 PyObject * obj0 = 0 ;
14712 PyObject * obj1 = 0 ;
14713 PyObject * obj2 = 0 ;
14714 char * kwnames[] = {
14715 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14716 };
14717
14718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14720 if (!SWIG_IsOK(res1)) {
14721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14722 }
14723 arg1 = reinterpret_cast< wxImage * >(argp1);
14724 {
14725 arg2 = wxString_in_helper(obj1);
14726 if (arg2 == NULL) SWIG_fail;
14727 temp2 = true;
14728 }
14729 {
14730 arg3 = wxString_in_helper(obj2);
14731 if (arg3 == NULL) SWIG_fail;
14732 temp3 = true;
14733 }
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14737 wxPyEndAllowThreads(__tstate);
14738 if (PyErr_Occurred()) SWIG_fail;
14739 }
14740 {
14741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14742 }
14743 {
14744 if (temp2)
14745 delete arg2;
14746 }
14747 {
14748 if (temp3)
14749 delete arg3;
14750 }
14751 return resultobj;
14752 fail:
14753 {
14754 if (temp2)
14755 delete arg2;
14756 }
14757 {
14758 if (temp3)
14759 delete arg3;
14760 }
14761 return NULL;
14762 }
14763
14764
14765 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14766 PyObject *resultobj = 0;
14767 wxInputStream *arg1 = 0 ;
14768 bool result;
14769 wxPyInputStream *temp1 ;
14770 bool created1 ;
14771 PyObject * obj0 = 0 ;
14772 char * kwnames[] = {
14773 (char *) "stream", NULL
14774 };
14775
14776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14777 {
14778 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14779 arg1 = temp1->m_wxis;
14780 created1 = false;
14781 } else {
14782 PyErr_Clear(); // clear the failure of the wxPyConvert above
14783 arg1 = wxPyCBInputStream_create(obj0, false);
14784 if (arg1 == NULL) {
14785 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14786 SWIG_fail;
14787 }
14788 created1 = true;
14789 }
14790 }
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 result = (bool)wxImage::CanRead(*arg1);
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 {
14798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14799 }
14800 {
14801 if (created1) delete arg1;
14802 }
14803 return resultobj;
14804 fail:
14805 {
14806 if (created1) delete arg1;
14807 }
14808 return NULL;
14809 }
14810
14811
14812 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14813 PyObject *resultobj = 0;
14814 wxImage *arg1 = (wxImage *) 0 ;
14815 wxInputStream *arg2 = 0 ;
14816 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14817 int arg4 = (int) -1 ;
14818 bool result;
14819 void *argp1 = 0 ;
14820 int res1 = 0 ;
14821 wxPyInputStream *temp2 ;
14822 bool created2 ;
14823 long val3 ;
14824 int ecode3 = 0 ;
14825 int val4 ;
14826 int ecode4 = 0 ;
14827 PyObject * obj0 = 0 ;
14828 PyObject * obj1 = 0 ;
14829 PyObject * obj2 = 0 ;
14830 PyObject * obj3 = 0 ;
14831 char * kwnames[] = {
14832 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14833 };
14834
14835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14837 if (!SWIG_IsOK(res1)) {
14838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14839 }
14840 arg1 = reinterpret_cast< wxImage * >(argp1);
14841 {
14842 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14843 arg2 = temp2->m_wxis;
14844 created2 = false;
14845 } else {
14846 PyErr_Clear(); // clear the failure of the wxPyConvert above
14847 arg2 = wxPyCBInputStream_create(obj1, false);
14848 if (arg2 == NULL) {
14849 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14850 SWIG_fail;
14851 }
14852 created2 = true;
14853 }
14854 }
14855 if (obj2) {
14856 ecode3 = SWIG_AsVal_long(obj2, &val3);
14857 if (!SWIG_IsOK(ecode3)) {
14858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14859 }
14860 arg3 = static_cast< long >(val3);
14861 }
14862 if (obj3) {
14863 ecode4 = SWIG_AsVal_int(obj3, &val4);
14864 if (!SWIG_IsOK(ecode4)) {
14865 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14866 }
14867 arg4 = static_cast< int >(val4);
14868 }
14869 {
14870 PyThreadState* __tstate = wxPyBeginAllowThreads();
14871 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14872 wxPyEndAllowThreads(__tstate);
14873 if (PyErr_Occurred()) SWIG_fail;
14874 }
14875 {
14876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14877 }
14878 {
14879 if (created2) delete arg2;
14880 }
14881 return resultobj;
14882 fail:
14883 {
14884 if (created2) delete arg2;
14885 }
14886 return NULL;
14887 }
14888
14889
14890 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14891 PyObject *resultobj = 0;
14892 wxImage *arg1 = (wxImage *) 0 ;
14893 wxInputStream *arg2 = 0 ;
14894 wxString *arg3 = 0 ;
14895 int arg4 = (int) -1 ;
14896 bool result;
14897 void *argp1 = 0 ;
14898 int res1 = 0 ;
14899 wxPyInputStream *temp2 ;
14900 bool created2 ;
14901 bool temp3 = false ;
14902 int val4 ;
14903 int ecode4 = 0 ;
14904 PyObject * obj0 = 0 ;
14905 PyObject * obj1 = 0 ;
14906 PyObject * obj2 = 0 ;
14907 PyObject * obj3 = 0 ;
14908 char * kwnames[] = {
14909 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14910 };
14911
14912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14914 if (!SWIG_IsOK(res1)) {
14915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14916 }
14917 arg1 = reinterpret_cast< wxImage * >(argp1);
14918 {
14919 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14920 arg2 = temp2->m_wxis;
14921 created2 = false;
14922 } else {
14923 PyErr_Clear(); // clear the failure of the wxPyConvert above
14924 arg2 = wxPyCBInputStream_create(obj1, false);
14925 if (arg2 == NULL) {
14926 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14927 SWIG_fail;
14928 }
14929 created2 = true;
14930 }
14931 }
14932 {
14933 arg3 = wxString_in_helper(obj2);
14934 if (arg3 == NULL) SWIG_fail;
14935 temp3 = true;
14936 }
14937 if (obj3) {
14938 ecode4 = SWIG_AsVal_int(obj3, &val4);
14939 if (!SWIG_IsOK(ecode4)) {
14940 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14941 }
14942 arg4 = static_cast< int >(val4);
14943 }
14944 {
14945 PyThreadState* __tstate = wxPyBeginAllowThreads();
14946 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14947 wxPyEndAllowThreads(__tstate);
14948 if (PyErr_Occurred()) SWIG_fail;
14949 }
14950 {
14951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14952 }
14953 {
14954 if (created2) delete arg2;
14955 }
14956 {
14957 if (temp3)
14958 delete arg3;
14959 }
14960 return resultobj;
14961 fail:
14962 {
14963 if (created2) delete arg2;
14964 }
14965 {
14966 if (temp3)
14967 delete arg3;
14968 }
14969 return NULL;
14970 }
14971
14972
14973 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14974 PyObject *resultobj = 0;
14975 wxImage *arg1 = (wxImage *) 0 ;
14976 bool result;
14977 void *argp1 = 0 ;
14978 int res1 = 0 ;
14979 PyObject *swig_obj[1] ;
14980
14981 if (!args) SWIG_fail;
14982 swig_obj[0] = args;
14983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14984 if (!SWIG_IsOK(res1)) {
14985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14986 }
14987 arg1 = reinterpret_cast< wxImage * >(argp1);
14988 {
14989 PyThreadState* __tstate = wxPyBeginAllowThreads();
14990 result = (bool)(arg1)->Ok();
14991 wxPyEndAllowThreads(__tstate);
14992 if (PyErr_Occurred()) SWIG_fail;
14993 }
14994 {
14995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14996 }
14997 return resultobj;
14998 fail:
14999 return NULL;
15000 }
15001
15002
15003 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15004 PyObject *resultobj = 0;
15005 wxImage *arg1 = (wxImage *) 0 ;
15006 int result;
15007 void *argp1 = 0 ;
15008 int res1 = 0 ;
15009 PyObject *swig_obj[1] ;
15010
15011 if (!args) SWIG_fail;
15012 swig_obj[0] = args;
15013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15014 if (!SWIG_IsOK(res1)) {
15015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15016 }
15017 arg1 = reinterpret_cast< wxImage * >(argp1);
15018 {
15019 PyThreadState* __tstate = wxPyBeginAllowThreads();
15020 result = (int)(arg1)->GetWidth();
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 resultobj = SWIG_From_int(static_cast< int >(result));
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15032 PyObject *resultobj = 0;
15033 wxImage *arg1 = (wxImage *) 0 ;
15034 int result;
15035 void *argp1 = 0 ;
15036 int res1 = 0 ;
15037 PyObject *swig_obj[1] ;
15038
15039 if (!args) SWIG_fail;
15040 swig_obj[0] = args;
15041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15042 if (!SWIG_IsOK(res1)) {
15043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15044 }
15045 arg1 = reinterpret_cast< wxImage * >(argp1);
15046 {
15047 PyThreadState* __tstate = wxPyBeginAllowThreads();
15048 result = (int)(arg1)->GetHeight();
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 resultobj = SWIG_From_int(static_cast< int >(result));
15053 return resultobj;
15054 fail:
15055 return NULL;
15056 }
15057
15058
15059 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15060 PyObject *resultobj = 0;
15061 wxImage *arg1 = (wxImage *) 0 ;
15062 wxSize result;
15063 void *argp1 = 0 ;
15064 int res1 = 0 ;
15065 PyObject *swig_obj[1] ;
15066
15067 if (!args) SWIG_fail;
15068 swig_obj[0] = args;
15069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15070 if (!SWIG_IsOK(res1)) {
15071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15072 }
15073 arg1 = reinterpret_cast< wxImage * >(argp1);
15074 {
15075 PyThreadState* __tstate = wxPyBeginAllowThreads();
15076 result = wxImage_GetSize(arg1);
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15081 return resultobj;
15082 fail:
15083 return NULL;
15084 }
15085
15086
15087 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15088 PyObject *resultobj = 0;
15089 wxImage *arg1 = (wxImage *) 0 ;
15090 wxRect *arg2 = 0 ;
15091 SwigValueWrapper<wxImage > result;
15092 void *argp1 = 0 ;
15093 int res1 = 0 ;
15094 wxRect temp2 ;
15095 PyObject * obj0 = 0 ;
15096 PyObject * obj1 = 0 ;
15097 char * kwnames[] = {
15098 (char *) "self",(char *) "rect", NULL
15099 };
15100
15101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15103 if (!SWIG_IsOK(res1)) {
15104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15105 }
15106 arg1 = reinterpret_cast< wxImage * >(argp1);
15107 {
15108 arg2 = &temp2;
15109 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15110 }
15111 {
15112 PyThreadState* __tstate = wxPyBeginAllowThreads();
15113 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15118 return resultobj;
15119 fail:
15120 return NULL;
15121 }
15122
15123
15124 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj = 0;
15126 wxImage *arg1 = (wxImage *) 0 ;
15127 wxSize *arg2 = 0 ;
15128 wxPoint *arg3 = 0 ;
15129 int arg4 = (int) -1 ;
15130 int arg5 = (int) -1 ;
15131 int arg6 = (int) -1 ;
15132 SwigValueWrapper<wxImage > result;
15133 void *argp1 = 0 ;
15134 int res1 = 0 ;
15135 wxSize temp2 ;
15136 wxPoint temp3 ;
15137 int val4 ;
15138 int ecode4 = 0 ;
15139 int val5 ;
15140 int ecode5 = 0 ;
15141 int val6 ;
15142 int ecode6 = 0 ;
15143 PyObject * obj0 = 0 ;
15144 PyObject * obj1 = 0 ;
15145 PyObject * obj2 = 0 ;
15146 PyObject * obj3 = 0 ;
15147 PyObject * obj4 = 0 ;
15148 PyObject * obj5 = 0 ;
15149 char * kwnames[] = {
15150 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15151 };
15152
15153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15155 if (!SWIG_IsOK(res1)) {
15156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15157 }
15158 arg1 = reinterpret_cast< wxImage * >(argp1);
15159 {
15160 arg2 = &temp2;
15161 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15162 }
15163 {
15164 arg3 = &temp3;
15165 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15166 }
15167 if (obj3) {
15168 ecode4 = SWIG_AsVal_int(obj3, &val4);
15169 if (!SWIG_IsOK(ecode4)) {
15170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15171 }
15172 arg4 = static_cast< int >(val4);
15173 }
15174 if (obj4) {
15175 ecode5 = SWIG_AsVal_int(obj4, &val5);
15176 if (!SWIG_IsOK(ecode5)) {
15177 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15178 }
15179 arg5 = static_cast< int >(val5);
15180 }
15181 if (obj5) {
15182 ecode6 = SWIG_AsVal_int(obj5, &val6);
15183 if (!SWIG_IsOK(ecode6)) {
15184 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15185 }
15186 arg6 = static_cast< int >(val6);
15187 }
15188 {
15189 PyThreadState* __tstate = wxPyBeginAllowThreads();
15190 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15195 return resultobj;
15196 fail:
15197 return NULL;
15198 }
15199
15200
15201 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15202 PyObject *resultobj = 0;
15203 wxImage *arg1 = (wxImage *) 0 ;
15204 SwigValueWrapper<wxImage > result;
15205 void *argp1 = 0 ;
15206 int res1 = 0 ;
15207 PyObject *swig_obj[1] ;
15208
15209 if (!args) SWIG_fail;
15210 swig_obj[0] = args;
15211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15212 if (!SWIG_IsOK(res1)) {
15213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15214 }
15215 arg1 = reinterpret_cast< wxImage * >(argp1);
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (arg1)->Copy();
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15230 PyObject *resultobj = 0;
15231 wxImage *arg1 = (wxImage *) 0 ;
15232 wxImage *arg2 = 0 ;
15233 int arg3 ;
15234 int arg4 ;
15235 void *argp1 = 0 ;
15236 int res1 = 0 ;
15237 void *argp2 = 0 ;
15238 int res2 = 0 ;
15239 int val3 ;
15240 int ecode3 = 0 ;
15241 int val4 ;
15242 int ecode4 = 0 ;
15243 PyObject * obj0 = 0 ;
15244 PyObject * obj1 = 0 ;
15245 PyObject * obj2 = 0 ;
15246 PyObject * obj3 = 0 ;
15247 char * kwnames[] = {
15248 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15249 };
15250
15251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15253 if (!SWIG_IsOK(res1)) {
15254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15255 }
15256 arg1 = reinterpret_cast< wxImage * >(argp1);
15257 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15258 if (!SWIG_IsOK(res2)) {
15259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15260 }
15261 if (!argp2) {
15262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15263 }
15264 arg2 = reinterpret_cast< wxImage * >(argp2);
15265 ecode3 = SWIG_AsVal_int(obj2, &val3);
15266 if (!SWIG_IsOK(ecode3)) {
15267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15268 }
15269 arg3 = static_cast< int >(val3);
15270 ecode4 = SWIG_AsVal_int(obj3, &val4);
15271 if (!SWIG_IsOK(ecode4)) {
15272 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15273 }
15274 arg4 = static_cast< int >(val4);
15275 {
15276 PyThreadState* __tstate = wxPyBeginAllowThreads();
15277 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15278 wxPyEndAllowThreads(__tstate);
15279 if (PyErr_Occurred()) SWIG_fail;
15280 }
15281 resultobj = SWIG_Py_Void();
15282 return resultobj;
15283 fail:
15284 return NULL;
15285 }
15286
15287
15288 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15289 PyObject *resultobj = 0;
15290 wxImage *arg1 = (wxImage *) 0 ;
15291 PyObject *result = 0 ;
15292 void *argp1 = 0 ;
15293 int res1 = 0 ;
15294 PyObject *swig_obj[1] ;
15295
15296 if (!args) SWIG_fail;
15297 swig_obj[0] = args;
15298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15299 if (!SWIG_IsOK(res1)) {
15300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15301 }
15302 arg1 = reinterpret_cast< wxImage * >(argp1);
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (PyObject *)wxImage_GetData(arg1);
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = result;
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15317 PyObject *resultobj = 0;
15318 wxImage *arg1 = (wxImage *) 0 ;
15319 buffer arg2 ;
15320 int arg3 ;
15321 void *argp1 = 0 ;
15322 int res1 = 0 ;
15323 PyObject * obj0 = 0 ;
15324 PyObject * obj1 = 0 ;
15325 char * kwnames[] = {
15326 (char *) "self",(char *) "data", NULL
15327 };
15328
15329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15331 if (!SWIG_IsOK(res1)) {
15332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15333 }
15334 arg1 = reinterpret_cast< wxImage * >(argp1);
15335 {
15336 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15337 }
15338 {
15339 PyThreadState* __tstate = wxPyBeginAllowThreads();
15340 wxImage_SetData(arg1,arg2,arg3);
15341 wxPyEndAllowThreads(__tstate);
15342 if (PyErr_Occurred()) SWIG_fail;
15343 }
15344 resultobj = SWIG_Py_Void();
15345 return resultobj;
15346 fail:
15347 return NULL;
15348 }
15349
15350
15351 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15352 PyObject *resultobj = 0;
15353 wxImage *arg1 = (wxImage *) 0 ;
15354 PyObject *result = 0 ;
15355 void *argp1 = 0 ;
15356 int res1 = 0 ;
15357 PyObject *swig_obj[1] ;
15358
15359 if (!args) SWIG_fail;
15360 swig_obj[0] = args;
15361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15362 if (!SWIG_IsOK(res1)) {
15363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15364 }
15365 arg1 = reinterpret_cast< wxImage * >(argp1);
15366 {
15367 PyThreadState* __tstate = wxPyBeginAllowThreads();
15368 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15369 wxPyEndAllowThreads(__tstate);
15370 if (PyErr_Occurred()) SWIG_fail;
15371 }
15372 resultobj = result;
15373 return resultobj;
15374 fail:
15375 return NULL;
15376 }
15377
15378
15379 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15380 PyObject *resultobj = 0;
15381 wxImage *arg1 = (wxImage *) 0 ;
15382 buffer arg2 ;
15383 int arg3 ;
15384 void *argp1 = 0 ;
15385 int res1 = 0 ;
15386 PyObject * obj0 = 0 ;
15387 PyObject * obj1 = 0 ;
15388 char * kwnames[] = {
15389 (char *) "self",(char *) "data", NULL
15390 };
15391
15392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage * >(argp1);
15398 {
15399 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15400 }
15401 {
15402 PyThreadState* __tstate = wxPyBeginAllowThreads();
15403 wxImage_SetDataBuffer(arg1,arg2,arg3);
15404 wxPyEndAllowThreads(__tstate);
15405 if (PyErr_Occurred()) SWIG_fail;
15406 }
15407 resultobj = SWIG_Py_Void();
15408 return resultobj;
15409 fail:
15410 return NULL;
15411 }
15412
15413
15414 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15415 PyObject *resultobj = 0;
15416 wxImage *arg1 = (wxImage *) 0 ;
15417 PyObject *result = 0 ;
15418 void *argp1 = 0 ;
15419 int res1 = 0 ;
15420 PyObject *swig_obj[1] ;
15421
15422 if (!args) SWIG_fail;
15423 swig_obj[0] = args;
15424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15425 if (!SWIG_IsOK(res1)) {
15426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15427 }
15428 arg1 = reinterpret_cast< wxImage * >(argp1);
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (PyObject *)wxImage_GetAlphaData(arg1);
15432 wxPyEndAllowThreads(__tstate);
15433 if (PyErr_Occurred()) SWIG_fail;
15434 }
15435 resultobj = result;
15436 return resultobj;
15437 fail:
15438 return NULL;
15439 }
15440
15441
15442 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15443 PyObject *resultobj = 0;
15444 wxImage *arg1 = (wxImage *) 0 ;
15445 buffer arg2 ;
15446 int arg3 ;
15447 void *argp1 = 0 ;
15448 int res1 = 0 ;
15449 PyObject * obj0 = 0 ;
15450 PyObject * obj1 = 0 ;
15451 char * kwnames[] = {
15452 (char *) "self",(char *) "alpha", NULL
15453 };
15454
15455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15457 if (!SWIG_IsOK(res1)) {
15458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15459 }
15460 arg1 = reinterpret_cast< wxImage * >(argp1);
15461 {
15462 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15463 }
15464 {
15465 PyThreadState* __tstate = wxPyBeginAllowThreads();
15466 wxImage_SetAlphaData(arg1,arg2,arg3);
15467 wxPyEndAllowThreads(__tstate);
15468 if (PyErr_Occurred()) SWIG_fail;
15469 }
15470 resultobj = SWIG_Py_Void();
15471 return resultobj;
15472 fail:
15473 return NULL;
15474 }
15475
15476
15477 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15478 PyObject *resultobj = 0;
15479 wxImage *arg1 = (wxImage *) 0 ;
15480 PyObject *result = 0 ;
15481 void *argp1 = 0 ;
15482 int res1 = 0 ;
15483 PyObject *swig_obj[1] ;
15484
15485 if (!args) SWIG_fail;
15486 swig_obj[0] = args;
15487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15488 if (!SWIG_IsOK(res1)) {
15489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15490 }
15491 arg1 = reinterpret_cast< wxImage * >(argp1);
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15495 wxPyEndAllowThreads(__tstate);
15496 if (PyErr_Occurred()) SWIG_fail;
15497 }
15498 resultobj = result;
15499 return resultobj;
15500 fail:
15501 return NULL;
15502 }
15503
15504
15505 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15506 PyObject *resultobj = 0;
15507 wxImage *arg1 = (wxImage *) 0 ;
15508 buffer arg2 ;
15509 int arg3 ;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 PyObject * obj0 = 0 ;
15513 PyObject * obj1 = 0 ;
15514 char * kwnames[] = {
15515 (char *) "self",(char *) "alpha", NULL
15516 };
15517
15518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15520 if (!SWIG_IsOK(res1)) {
15521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15522 }
15523 arg1 = reinterpret_cast< wxImage * >(argp1);
15524 {
15525 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15526 }
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 resultobj = SWIG_Py_Void();
15534 return resultobj;
15535 fail:
15536 return NULL;
15537 }
15538
15539
15540 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15541 PyObject *resultobj = 0;
15542 wxImage *arg1 = (wxImage *) 0 ;
15543 byte arg2 ;
15544 byte arg3 ;
15545 byte arg4 ;
15546 void *argp1 = 0 ;
15547 int res1 = 0 ;
15548 unsigned char val2 ;
15549 int ecode2 = 0 ;
15550 unsigned char val3 ;
15551 int ecode3 = 0 ;
15552 unsigned char val4 ;
15553 int ecode4 = 0 ;
15554 PyObject * obj0 = 0 ;
15555 PyObject * obj1 = 0 ;
15556 PyObject * obj2 = 0 ;
15557 PyObject * obj3 = 0 ;
15558 char * kwnames[] = {
15559 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15560 };
15561
15562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15564 if (!SWIG_IsOK(res1)) {
15565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15566 }
15567 arg1 = reinterpret_cast< wxImage * >(argp1);
15568 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15569 if (!SWIG_IsOK(ecode2)) {
15570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15571 }
15572 arg2 = static_cast< byte >(val2);
15573 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15574 if (!SWIG_IsOK(ecode3)) {
15575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15576 }
15577 arg3 = static_cast< byte >(val3);
15578 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15579 if (!SWIG_IsOK(ecode4)) {
15580 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15581 }
15582 arg4 = static_cast< byte >(val4);
15583 {
15584 PyThreadState* __tstate = wxPyBeginAllowThreads();
15585 (arg1)->SetMaskColour(arg2,arg3,arg4);
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 resultobj = SWIG_Py_Void();
15590 return resultobj;
15591 fail:
15592 return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15597 PyObject *resultobj = 0;
15598 wxImage *arg1 = (wxImage *) 0 ;
15599 byte *arg2 = (byte *) 0 ;
15600 byte *arg3 = (byte *) 0 ;
15601 byte *arg4 = (byte *) 0 ;
15602 void *argp1 = 0 ;
15603 int res1 = 0 ;
15604 byte temp2 ;
15605 int res2 = SWIG_TMPOBJ ;
15606 byte temp3 ;
15607 int res3 = SWIG_TMPOBJ ;
15608 byte temp4 ;
15609 int res4 = SWIG_TMPOBJ ;
15610 PyObject *swig_obj[1] ;
15611
15612 arg2 = &temp2;
15613 arg3 = &temp3;
15614 arg4 = &temp4;
15615 if (!args) SWIG_fail;
15616 swig_obj[0] = args;
15617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15618 if (!SWIG_IsOK(res1)) {
15619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15620 }
15621 arg1 = reinterpret_cast< wxImage * >(argp1);
15622 {
15623 PyThreadState* __tstate = wxPyBeginAllowThreads();
15624 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 resultobj = SWIG_Py_Void();
15629 if (SWIG_IsTmpObj(res2)) {
15630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15631 } else {
15632 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15634 }
15635 if (SWIG_IsTmpObj(res3)) {
15636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15637 } else {
15638 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15640 }
15641 if (SWIG_IsTmpObj(res4)) {
15642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15643 } else {
15644 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15646 }
15647 return resultobj;
15648 fail:
15649 return NULL;
15650 }
15651
15652
15653 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15654 PyObject *resultobj = 0;
15655 wxImage *arg1 = (wxImage *) 0 ;
15656 byte result;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 PyObject *swig_obj[1] ;
15660
15661 if (!args) SWIG_fail;
15662 swig_obj[0] = args;
15663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15664 if (!SWIG_IsOK(res1)) {
15665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15666 }
15667 arg1 = reinterpret_cast< wxImage * >(argp1);
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 result = (byte)(arg1)->GetMaskRed();
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15682 PyObject *resultobj = 0;
15683 wxImage *arg1 = (wxImage *) 0 ;
15684 byte result;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 PyObject *swig_obj[1] ;
15688
15689 if (!args) SWIG_fail;
15690 swig_obj[0] = args;
15691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15692 if (!SWIG_IsOK(res1)) {
15693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15694 }
15695 arg1 = reinterpret_cast< wxImage * >(argp1);
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 result = (byte)(arg1)->GetMaskGreen();
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15703 return resultobj;
15704 fail:
15705 return NULL;
15706 }
15707
15708
15709 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15710 PyObject *resultobj = 0;
15711 wxImage *arg1 = (wxImage *) 0 ;
15712 byte result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 PyObject *swig_obj[1] ;
15716
15717 if (!args) SWIG_fail;
15718 swig_obj[0] = args;
15719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15720 if (!SWIG_IsOK(res1)) {
15721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15722 }
15723 arg1 = reinterpret_cast< wxImage * >(argp1);
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (byte)(arg1)->GetMaskBlue();
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15738 PyObject *resultobj = 0;
15739 wxImage *arg1 = (wxImage *) 0 ;
15740 bool arg2 = (bool) true ;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 bool val2 ;
15744 int ecode2 = 0 ;
15745 PyObject * obj0 = 0 ;
15746 PyObject * obj1 = 0 ;
15747 char * kwnames[] = {
15748 (char *) "self",(char *) "mask", NULL
15749 };
15750
15751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15753 if (!SWIG_IsOK(res1)) {
15754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15755 }
15756 arg1 = reinterpret_cast< wxImage * >(argp1);
15757 if (obj1) {
15758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15759 if (!SWIG_IsOK(ecode2)) {
15760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15761 }
15762 arg2 = static_cast< bool >(val2);
15763 }
15764 {
15765 PyThreadState* __tstate = wxPyBeginAllowThreads();
15766 (arg1)->SetMask(arg2);
15767 wxPyEndAllowThreads(__tstate);
15768 if (PyErr_Occurred()) SWIG_fail;
15769 }
15770 resultobj = SWIG_Py_Void();
15771 return resultobj;
15772 fail:
15773 return NULL;
15774 }
15775
15776
15777 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15778 PyObject *resultobj = 0;
15779 wxImage *arg1 = (wxImage *) 0 ;
15780 bool result;
15781 void *argp1 = 0 ;
15782 int res1 = 0 ;
15783 PyObject *swig_obj[1] ;
15784
15785 if (!args) SWIG_fail;
15786 swig_obj[0] = args;
15787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15788 if (!SWIG_IsOK(res1)) {
15789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15790 }
15791 arg1 = reinterpret_cast< wxImage * >(argp1);
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (bool)(arg1)->HasMask();
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 {
15799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15800 }
15801 return resultobj;
15802 fail:
15803 return NULL;
15804 }
15805
15806
15807 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15808 PyObject *resultobj = 0;
15809 wxImage *arg1 = (wxImage *) 0 ;
15810 double arg2 ;
15811 wxPoint *arg3 = 0 ;
15812 bool arg4 = (bool) true ;
15813 wxPoint *arg5 = (wxPoint *) NULL ;
15814 SwigValueWrapper<wxImage > result;
15815 void *argp1 = 0 ;
15816 int res1 = 0 ;
15817 double val2 ;
15818 int ecode2 = 0 ;
15819 wxPoint temp3 ;
15820 bool val4 ;
15821 int ecode4 = 0 ;
15822 void *argp5 = 0 ;
15823 int res5 = 0 ;
15824 PyObject * obj0 = 0 ;
15825 PyObject * obj1 = 0 ;
15826 PyObject * obj2 = 0 ;
15827 PyObject * obj3 = 0 ;
15828 PyObject * obj4 = 0 ;
15829 char * kwnames[] = {
15830 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15831 };
15832
15833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15835 if (!SWIG_IsOK(res1)) {
15836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15837 }
15838 arg1 = reinterpret_cast< wxImage * >(argp1);
15839 ecode2 = SWIG_AsVal_double(obj1, &val2);
15840 if (!SWIG_IsOK(ecode2)) {
15841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15842 }
15843 arg2 = static_cast< double >(val2);
15844 {
15845 arg3 = &temp3;
15846 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15847 }
15848 if (obj3) {
15849 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15850 if (!SWIG_IsOK(ecode4)) {
15851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15852 }
15853 arg4 = static_cast< bool >(val4);
15854 }
15855 if (obj4) {
15856 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15857 if (!SWIG_IsOK(res5)) {
15858 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15859 }
15860 arg5 = reinterpret_cast< wxPoint * >(argp5);
15861 }
15862 {
15863 PyThreadState* __tstate = wxPyBeginAllowThreads();
15864 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15869 return resultobj;
15870 fail:
15871 return NULL;
15872 }
15873
15874
15875 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15876 PyObject *resultobj = 0;
15877 wxImage *arg1 = (wxImage *) 0 ;
15878 bool arg2 = (bool) true ;
15879 SwigValueWrapper<wxImage > result;
15880 void *argp1 = 0 ;
15881 int res1 = 0 ;
15882 bool val2 ;
15883 int ecode2 = 0 ;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 char * kwnames[] = {
15887 (char *) "self",(char *) "clockwise", NULL
15888 };
15889
15890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15892 if (!SWIG_IsOK(res1)) {
15893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15894 }
15895 arg1 = reinterpret_cast< wxImage * >(argp1);
15896 if (obj1) {
15897 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15898 if (!SWIG_IsOK(ecode2)) {
15899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15900 }
15901 arg2 = static_cast< bool >(val2);
15902 }
15903 {
15904 PyThreadState* __tstate = wxPyBeginAllowThreads();
15905 result = (arg1)->Rotate90(arg2);
15906 wxPyEndAllowThreads(__tstate);
15907 if (PyErr_Occurred()) SWIG_fail;
15908 }
15909 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15910 return resultobj;
15911 fail:
15912 return NULL;
15913 }
15914
15915
15916 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15917 PyObject *resultobj = 0;
15918 wxImage *arg1 = (wxImage *) 0 ;
15919 bool arg2 = (bool) true ;
15920 SwigValueWrapper<wxImage > result;
15921 void *argp1 = 0 ;
15922 int res1 = 0 ;
15923 bool val2 ;
15924 int ecode2 = 0 ;
15925 PyObject * obj0 = 0 ;
15926 PyObject * obj1 = 0 ;
15927 char * kwnames[] = {
15928 (char *) "self",(char *) "horizontally", NULL
15929 };
15930
15931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15933 if (!SWIG_IsOK(res1)) {
15934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15935 }
15936 arg1 = reinterpret_cast< wxImage * >(argp1);
15937 if (obj1) {
15938 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15939 if (!SWIG_IsOK(ecode2)) {
15940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15941 }
15942 arg2 = static_cast< bool >(val2);
15943 }
15944 {
15945 PyThreadState* __tstate = wxPyBeginAllowThreads();
15946 result = (arg1)->Mirror(arg2);
15947 wxPyEndAllowThreads(__tstate);
15948 if (PyErr_Occurred()) SWIG_fail;
15949 }
15950 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15951 return resultobj;
15952 fail:
15953 return NULL;
15954 }
15955
15956
15957 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15958 PyObject *resultobj = 0;
15959 wxImage *arg1 = (wxImage *) 0 ;
15960 byte arg2 ;
15961 byte arg3 ;
15962 byte arg4 ;
15963 byte arg5 ;
15964 byte arg6 ;
15965 byte arg7 ;
15966 void *argp1 = 0 ;
15967 int res1 = 0 ;
15968 unsigned char val2 ;
15969 int ecode2 = 0 ;
15970 unsigned char val3 ;
15971 int ecode3 = 0 ;
15972 unsigned char val4 ;
15973 int ecode4 = 0 ;
15974 unsigned char val5 ;
15975 int ecode5 = 0 ;
15976 unsigned char val6 ;
15977 int ecode6 = 0 ;
15978 unsigned char val7 ;
15979 int ecode7 = 0 ;
15980 PyObject * obj0 = 0 ;
15981 PyObject * obj1 = 0 ;
15982 PyObject * obj2 = 0 ;
15983 PyObject * obj3 = 0 ;
15984 PyObject * obj4 = 0 ;
15985 PyObject * obj5 = 0 ;
15986 PyObject * obj6 = 0 ;
15987 char * kwnames[] = {
15988 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15989 };
15990
15991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15993 if (!SWIG_IsOK(res1)) {
15994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15995 }
15996 arg1 = reinterpret_cast< wxImage * >(argp1);
15997 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15998 if (!SWIG_IsOK(ecode2)) {
15999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16000 }
16001 arg2 = static_cast< byte >(val2);
16002 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16003 if (!SWIG_IsOK(ecode3)) {
16004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16005 }
16006 arg3 = static_cast< byte >(val3);
16007 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16008 if (!SWIG_IsOK(ecode4)) {
16009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16010 }
16011 arg4 = static_cast< byte >(val4);
16012 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16013 if (!SWIG_IsOK(ecode5)) {
16014 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16015 }
16016 arg5 = static_cast< byte >(val5);
16017 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16018 if (!SWIG_IsOK(ecode6)) {
16019 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16020 }
16021 arg6 = static_cast< byte >(val6);
16022 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16023 if (!SWIG_IsOK(ecode7)) {
16024 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16025 }
16026 arg7 = static_cast< byte >(val7);
16027 {
16028 PyThreadState* __tstate = wxPyBeginAllowThreads();
16029 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16030 wxPyEndAllowThreads(__tstate);
16031 if (PyErr_Occurred()) SWIG_fail;
16032 }
16033 resultobj = SWIG_Py_Void();
16034 return resultobj;
16035 fail:
16036 return NULL;
16037 }
16038
16039
16040 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16041 PyObject *resultobj = 0;
16042 wxImage *arg1 = (wxImage *) 0 ;
16043 double arg2 = (double) 0.299 ;
16044 double arg3 = (double) 0.587 ;
16045 double arg4 = (double) 0.114 ;
16046 SwigValueWrapper<wxImage > result;
16047 void *argp1 = 0 ;
16048 int res1 = 0 ;
16049 double val2 ;
16050 int ecode2 = 0 ;
16051 double val3 ;
16052 int ecode3 = 0 ;
16053 double val4 ;
16054 int ecode4 = 0 ;
16055 PyObject * obj0 = 0 ;
16056 PyObject * obj1 = 0 ;
16057 PyObject * obj2 = 0 ;
16058 PyObject * obj3 = 0 ;
16059 char * kwnames[] = {
16060 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16061 };
16062
16063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16065 if (!SWIG_IsOK(res1)) {
16066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16067 }
16068 arg1 = reinterpret_cast< wxImage * >(argp1);
16069 if (obj1) {
16070 ecode2 = SWIG_AsVal_double(obj1, &val2);
16071 if (!SWIG_IsOK(ecode2)) {
16072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16073 }
16074 arg2 = static_cast< double >(val2);
16075 }
16076 if (obj2) {
16077 ecode3 = SWIG_AsVal_double(obj2, &val3);
16078 if (!SWIG_IsOK(ecode3)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16080 }
16081 arg3 = static_cast< double >(val3);
16082 }
16083 if (obj3) {
16084 ecode4 = SWIG_AsVal_double(obj3, &val4);
16085 if (!SWIG_IsOK(ecode4)) {
16086 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16087 }
16088 arg4 = static_cast< double >(val4);
16089 }
16090 {
16091 PyThreadState* __tstate = wxPyBeginAllowThreads();
16092 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16093 wxPyEndAllowThreads(__tstate);
16094 if (PyErr_Occurred()) SWIG_fail;
16095 }
16096 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16104 PyObject *resultobj = 0;
16105 wxImage *arg1 = (wxImage *) 0 ;
16106 byte arg2 ;
16107 byte arg3 ;
16108 byte arg4 ;
16109 SwigValueWrapper<wxImage > result;
16110 void *argp1 = 0 ;
16111 int res1 = 0 ;
16112 unsigned char val2 ;
16113 int ecode2 = 0 ;
16114 unsigned char val3 ;
16115 int ecode3 = 0 ;
16116 unsigned char val4 ;
16117 int ecode4 = 0 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 PyObject * obj2 = 0 ;
16121 PyObject * obj3 = 0 ;
16122 char * kwnames[] = {
16123 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16124 };
16125
16126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16130 }
16131 arg1 = reinterpret_cast< wxImage * >(argp1);
16132 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16133 if (!SWIG_IsOK(ecode2)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16135 }
16136 arg2 = static_cast< byte >(val2);
16137 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16138 if (!SWIG_IsOK(ecode3)) {
16139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16140 }
16141 arg3 = static_cast< byte >(val3);
16142 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16143 if (!SWIG_IsOK(ecode4)) {
16144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16145 }
16146 arg4 = static_cast< byte >(val4);
16147 {
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16161 PyObject *resultobj = 0;
16162 wxImage *arg1 = (wxImage *) 0 ;
16163 wxString *arg2 = 0 ;
16164 wxString *arg3 = 0 ;
16165 void *argp1 = 0 ;
16166 int res1 = 0 ;
16167 bool temp2 = false ;
16168 bool temp3 = false ;
16169 PyObject * obj0 = 0 ;
16170 PyObject * obj1 = 0 ;
16171 PyObject * obj2 = 0 ;
16172 char * kwnames[] = {
16173 (char *) "self",(char *) "name",(char *) "value", NULL
16174 };
16175
16176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16178 if (!SWIG_IsOK(res1)) {
16179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16180 }
16181 arg1 = reinterpret_cast< wxImage * >(argp1);
16182 {
16183 arg2 = wxString_in_helper(obj1);
16184 if (arg2 == NULL) SWIG_fail;
16185 temp2 = true;
16186 }
16187 {
16188 arg3 = wxString_in_helper(obj2);
16189 if (arg3 == NULL) SWIG_fail;
16190 temp3 = true;
16191 }
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = SWIG_Py_Void();
16199 {
16200 if (temp2)
16201 delete arg2;
16202 }
16203 {
16204 if (temp3)
16205 delete arg3;
16206 }
16207 return resultobj;
16208 fail:
16209 {
16210 if (temp2)
16211 delete arg2;
16212 }
16213 {
16214 if (temp3)
16215 delete arg3;
16216 }
16217 return NULL;
16218 }
16219
16220
16221 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16222 PyObject *resultobj = 0;
16223 wxImage *arg1 = (wxImage *) 0 ;
16224 wxString *arg2 = 0 ;
16225 int arg3 ;
16226 void *argp1 = 0 ;
16227 int res1 = 0 ;
16228 bool temp2 = false ;
16229 int val3 ;
16230 int ecode3 = 0 ;
16231 PyObject * obj0 = 0 ;
16232 PyObject * obj1 = 0 ;
16233 PyObject * obj2 = 0 ;
16234 char * kwnames[] = {
16235 (char *) "self",(char *) "name",(char *) "value", NULL
16236 };
16237
16238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16240 if (!SWIG_IsOK(res1)) {
16241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16242 }
16243 arg1 = reinterpret_cast< wxImage * >(argp1);
16244 {
16245 arg2 = wxString_in_helper(obj1);
16246 if (arg2 == NULL) SWIG_fail;
16247 temp2 = true;
16248 }
16249 ecode3 = SWIG_AsVal_int(obj2, &val3);
16250 if (!SWIG_IsOK(ecode3)) {
16251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16252 }
16253 arg3 = static_cast< int >(val3);
16254 {
16255 PyThreadState* __tstate = wxPyBeginAllowThreads();
16256 (arg1)->SetOption((wxString const &)*arg2,arg3);
16257 wxPyEndAllowThreads(__tstate);
16258 if (PyErr_Occurred()) SWIG_fail;
16259 }
16260 resultobj = SWIG_Py_Void();
16261 {
16262 if (temp2)
16263 delete arg2;
16264 }
16265 return resultobj;
16266 fail:
16267 {
16268 if (temp2)
16269 delete arg2;
16270 }
16271 return NULL;
16272 }
16273
16274
16275 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16276 PyObject *resultobj = 0;
16277 wxImage *arg1 = (wxImage *) 0 ;
16278 wxString *arg2 = 0 ;
16279 wxString result;
16280 void *argp1 = 0 ;
16281 int res1 = 0 ;
16282 bool temp2 = false ;
16283 PyObject * obj0 = 0 ;
16284 PyObject * obj1 = 0 ;
16285 char * kwnames[] = {
16286 (char *) "self",(char *) "name", NULL
16287 };
16288
16289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16291 if (!SWIG_IsOK(res1)) {
16292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16293 }
16294 arg1 = reinterpret_cast< wxImage * >(argp1);
16295 {
16296 arg2 = wxString_in_helper(obj1);
16297 if (arg2 == NULL) SWIG_fail;
16298 temp2 = true;
16299 }
16300 {
16301 PyThreadState* __tstate = wxPyBeginAllowThreads();
16302 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16303 wxPyEndAllowThreads(__tstate);
16304 if (PyErr_Occurred()) SWIG_fail;
16305 }
16306 {
16307 #if wxUSE_UNICODE
16308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16309 #else
16310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16311 #endif
16312 }
16313 {
16314 if (temp2)
16315 delete arg2;
16316 }
16317 return resultobj;
16318 fail:
16319 {
16320 if (temp2)
16321 delete arg2;
16322 }
16323 return NULL;
16324 }
16325
16326
16327 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16328 PyObject *resultobj = 0;
16329 wxImage *arg1 = (wxImage *) 0 ;
16330 wxString *arg2 = 0 ;
16331 int result;
16332 void *argp1 = 0 ;
16333 int res1 = 0 ;
16334 bool temp2 = false ;
16335 PyObject * obj0 = 0 ;
16336 PyObject * obj1 = 0 ;
16337 char * kwnames[] = {
16338 (char *) "self",(char *) "name", NULL
16339 };
16340
16341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16343 if (!SWIG_IsOK(res1)) {
16344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16345 }
16346 arg1 = reinterpret_cast< wxImage * >(argp1);
16347 {
16348 arg2 = wxString_in_helper(obj1);
16349 if (arg2 == NULL) SWIG_fail;
16350 temp2 = true;
16351 }
16352 {
16353 PyThreadState* __tstate = wxPyBeginAllowThreads();
16354 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 resultobj = SWIG_From_int(static_cast< int >(result));
16359 {
16360 if (temp2)
16361 delete arg2;
16362 }
16363 return resultobj;
16364 fail:
16365 {
16366 if (temp2)
16367 delete arg2;
16368 }
16369 return NULL;
16370 }
16371
16372
16373 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16374 PyObject *resultobj = 0;
16375 wxImage *arg1 = (wxImage *) 0 ;
16376 wxString *arg2 = 0 ;
16377 bool result;
16378 void *argp1 = 0 ;
16379 int res1 = 0 ;
16380 bool temp2 = false ;
16381 PyObject * obj0 = 0 ;
16382 PyObject * obj1 = 0 ;
16383 char * kwnames[] = {
16384 (char *) "self",(char *) "name", NULL
16385 };
16386
16387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16389 if (!SWIG_IsOK(res1)) {
16390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16391 }
16392 arg1 = reinterpret_cast< wxImage * >(argp1);
16393 {
16394 arg2 = wxString_in_helper(obj1);
16395 if (arg2 == NULL) SWIG_fail;
16396 temp2 = true;
16397 }
16398 {
16399 PyThreadState* __tstate = wxPyBeginAllowThreads();
16400 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16401 wxPyEndAllowThreads(__tstate);
16402 if (PyErr_Occurred()) SWIG_fail;
16403 }
16404 {
16405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16406 }
16407 {
16408 if (temp2)
16409 delete arg2;
16410 }
16411 return resultobj;
16412 fail:
16413 {
16414 if (temp2)
16415 delete arg2;
16416 }
16417 return NULL;
16418 }
16419
16420
16421 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj = 0;
16423 wxImage *arg1 = (wxImage *) 0 ;
16424 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16425 unsigned long result;
16426 void *argp1 = 0 ;
16427 int res1 = 0 ;
16428 unsigned long val2 ;
16429 int ecode2 = 0 ;
16430 PyObject * obj0 = 0 ;
16431 PyObject * obj1 = 0 ;
16432 char * kwnames[] = {
16433 (char *) "self",(char *) "stopafter", NULL
16434 };
16435
16436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16438 if (!SWIG_IsOK(res1)) {
16439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16440 }
16441 arg1 = reinterpret_cast< wxImage * >(argp1);
16442 if (obj1) {
16443 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16444 if (!SWIG_IsOK(ecode2)) {
16445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16446 }
16447 arg2 = static_cast< unsigned long >(val2);
16448 }
16449 {
16450 PyThreadState* __tstate = wxPyBeginAllowThreads();
16451 result = (unsigned long)(arg1)->CountColours(arg2);
16452 wxPyEndAllowThreads(__tstate);
16453 if (PyErr_Occurred()) SWIG_fail;
16454 }
16455 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16456 return resultobj;
16457 fail:
16458 return NULL;
16459 }
16460
16461
16462 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16463 PyObject *resultobj = 0;
16464 wxImage *arg1 = (wxImage *) 0 ;
16465 wxImageHistogram *arg2 = 0 ;
16466 unsigned long result;
16467 void *argp1 = 0 ;
16468 int res1 = 0 ;
16469 void *argp2 = 0 ;
16470 int res2 = 0 ;
16471 PyObject * obj0 = 0 ;
16472 PyObject * obj1 = 0 ;
16473 char * kwnames[] = {
16474 (char *) "self",(char *) "h", NULL
16475 };
16476
16477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16479 if (!SWIG_IsOK(res1)) {
16480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16481 }
16482 arg1 = reinterpret_cast< wxImage * >(argp1);
16483 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16484 if (!SWIG_IsOK(res2)) {
16485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16486 }
16487 if (!argp2) {
16488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16489 }
16490 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16494 wxPyEndAllowThreads(__tstate);
16495 if (PyErr_Occurred()) SWIG_fail;
16496 }
16497 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16498 return resultobj;
16499 fail:
16500 return NULL;
16501 }
16502
16503
16504 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16505 PyObject *resultobj = 0;
16506 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 PyObject * obj0 = 0 ;
16510 char * kwnames[] = {
16511 (char *) "handler", NULL
16512 };
16513
16514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16516 if (!SWIG_IsOK(res1)) {
16517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16518 }
16519 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16520 {
16521 PyThreadState* __tstate = wxPyBeginAllowThreads();
16522 wxImage::AddHandler(arg1);
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 resultobj = SWIG_Py_Void();
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16536 void *argp1 = 0 ;
16537 int res1 = 0 ;
16538 PyObject * obj0 = 0 ;
16539 char * kwnames[] = {
16540 (char *) "handler", NULL
16541 };
16542
16543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16545 if (!SWIG_IsOK(res1)) {
16546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16547 }
16548 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 wxImage::InsertHandler(arg1);
16552 wxPyEndAllowThreads(__tstate);
16553 if (PyErr_Occurred()) SWIG_fail;
16554 }
16555 resultobj = SWIG_Py_Void();
16556 return resultobj;
16557 fail:
16558 return NULL;
16559 }
16560
16561
16562 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16563 PyObject *resultobj = 0;
16564 wxString *arg1 = 0 ;
16565 bool result;
16566 bool temp1 = false ;
16567 PyObject * obj0 = 0 ;
16568 char * kwnames[] = {
16569 (char *) "name", NULL
16570 };
16571
16572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16573 {
16574 arg1 = wxString_in_helper(obj0);
16575 if (arg1 == NULL) SWIG_fail;
16576 temp1 = true;
16577 }
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 {
16585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16586 }
16587 {
16588 if (temp1)
16589 delete arg1;
16590 }
16591 return resultobj;
16592 fail:
16593 {
16594 if (temp1)
16595 delete arg1;
16596 }
16597 return NULL;
16598 }
16599
16600
16601 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16602 PyObject *resultobj = 0;
16603 PyObject *result = 0 ;
16604
16605 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16606 {
16607 PyThreadState* __tstate = wxPyBeginAllowThreads();
16608 result = (PyObject *)wxImage_GetHandlers();
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 resultobj = result;
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16620 PyObject *resultobj = 0;
16621 wxString result;
16622
16623 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16624 {
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = wxImage::GetImageExtWildcard();
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 {
16631 #if wxUSE_UNICODE
16632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16633 #else
16634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16635 #endif
16636 }
16637 return resultobj;
16638 fail:
16639 return NULL;
16640 }
16641
16642
16643 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj = 0;
16645 wxImage *arg1 = (wxImage *) 0 ;
16646 int arg2 = (int) -1 ;
16647 wxBitmap result;
16648 void *argp1 = 0 ;
16649 int res1 = 0 ;
16650 int val2 ;
16651 int ecode2 = 0 ;
16652 PyObject * obj0 = 0 ;
16653 PyObject * obj1 = 0 ;
16654 char * kwnames[] = {
16655 (char *) "self",(char *) "depth", NULL
16656 };
16657
16658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16660 if (!SWIG_IsOK(res1)) {
16661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16662 }
16663 arg1 = reinterpret_cast< wxImage * >(argp1);
16664 if (obj1) {
16665 ecode2 = SWIG_AsVal_int(obj1, &val2);
16666 if (!SWIG_IsOK(ecode2)) {
16667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16668 }
16669 arg2 = static_cast< int >(val2);
16670 }
16671 {
16672 if (!wxPyCheckForApp()) SWIG_fail;
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = wxImage_ConvertToBitmap(arg1,arg2);
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16686 PyObject *resultobj = 0;
16687 wxImage *arg1 = (wxImage *) 0 ;
16688 byte arg2 ;
16689 byte arg3 ;
16690 byte arg4 ;
16691 wxBitmap result;
16692 void *argp1 = 0 ;
16693 int res1 = 0 ;
16694 unsigned char val2 ;
16695 int ecode2 = 0 ;
16696 unsigned char val3 ;
16697 int ecode3 = 0 ;
16698 unsigned char val4 ;
16699 int ecode4 = 0 ;
16700 PyObject * obj0 = 0 ;
16701 PyObject * obj1 = 0 ;
16702 PyObject * obj2 = 0 ;
16703 PyObject * obj3 = 0 ;
16704 char * kwnames[] = {
16705 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16706 };
16707
16708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16710 if (!SWIG_IsOK(res1)) {
16711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16712 }
16713 arg1 = reinterpret_cast< wxImage * >(argp1);
16714 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16715 if (!SWIG_IsOK(ecode2)) {
16716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16717 }
16718 arg2 = static_cast< byte >(val2);
16719 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16720 if (!SWIG_IsOK(ecode3)) {
16721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16722 }
16723 arg3 = static_cast< byte >(val3);
16724 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16725 if (!SWIG_IsOK(ecode4)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16727 }
16728 arg4 = static_cast< byte >(val4);
16729 {
16730 if (!wxPyCheckForApp()) SWIG_fail;
16731 PyThreadState* __tstate = wxPyBeginAllowThreads();
16732 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj = 0;
16745 wxImage *arg1 = (wxImage *) 0 ;
16746 double arg2 ;
16747 void *argp1 = 0 ;
16748 int res1 = 0 ;
16749 double val2 ;
16750 int ecode2 = 0 ;
16751 PyObject * obj0 = 0 ;
16752 PyObject * obj1 = 0 ;
16753 char * kwnames[] = {
16754 (char *) "self",(char *) "angle", NULL
16755 };
16756
16757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16759 if (!SWIG_IsOK(res1)) {
16760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16761 }
16762 arg1 = reinterpret_cast< wxImage * >(argp1);
16763 ecode2 = SWIG_AsVal_double(obj1, &val2);
16764 if (!SWIG_IsOK(ecode2)) {
16765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16766 }
16767 arg2 = static_cast< double >(val2);
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 (arg1)->RotateHue(arg2);
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 resultobj = SWIG_Py_Void();
16775 return resultobj;
16776 fail:
16777 return NULL;
16778 }
16779
16780
16781 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj = 0;
16783 wxImage_RGBValue arg1 ;
16784 wxImage_HSVValue result;
16785 void *argp1 ;
16786 int res1 = 0 ;
16787 PyObject * obj0 = 0 ;
16788 char * kwnames[] = {
16789 (char *) "rgb", NULL
16790 };
16791
16792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16793 {
16794 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16795 if (!SWIG_IsOK(res1)) {
16796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16797 }
16798 if (!argp1) {
16799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16800 } else {
16801 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16802 arg1 = *temp;
16803 if (SWIG_IsNewObj(res1)) delete temp;
16804 }
16805 }
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 result = wxImage::RGBtoHSV(arg1);
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16820 PyObject *resultobj = 0;
16821 wxImage_HSVValue arg1 ;
16822 wxImage_RGBValue result;
16823 void *argp1 ;
16824 int res1 = 0 ;
16825 PyObject * obj0 = 0 ;
16826 char * kwnames[] = {
16827 (char *) "hsv", NULL
16828 };
16829
16830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16831 {
16832 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16833 if (!SWIG_IsOK(res1)) {
16834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16835 }
16836 if (!argp1) {
16837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16838 } else {
16839 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16840 arg1 = *temp;
16841 if (SWIG_IsNewObj(res1)) delete temp;
16842 }
16843 }
16844 {
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 result = wxImage::HSVtoRGB(arg1);
16847 wxPyEndAllowThreads(__tstate);
16848 if (PyErr_Occurred()) SWIG_fail;
16849 }
16850 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16851 return resultobj;
16852 fail:
16853 return NULL;
16854 }
16855
16856
16857 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16858 PyObject *obj;
16859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16860 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16861 return SWIG_Py_Void();
16862 }
16863
16864 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16865 return SWIG_Python_InitShadowInstance(args);
16866 }
16867
16868 SWIGINTERN int NullImage_set(PyObject *) {
16869 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16870 return 1;
16871 }
16872
16873
16874 SWIGINTERN PyObject *NullImage_get(void) {
16875 PyObject *pyobj = 0;
16876
16877 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16878 return pyobj;
16879 }
16880
16881
16882 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16883 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16884 return 1;
16885 }
16886
16887
16888 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16889 PyObject *pyobj = 0;
16890
16891 {
16892 #if wxUSE_UNICODE
16893 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16894 #else
16895 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16896 #endif
16897 }
16898 return pyobj;
16899 }
16900
16901
16902 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16903 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16904 return 1;
16905 }
16906
16907
16908 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16909 PyObject *pyobj = 0;
16910
16911 {
16912 #if wxUSE_UNICODE
16913 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16914 #else
16915 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16916 #endif
16917 }
16918 return pyobj;
16919 }
16920
16921
16922 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16923 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16924 return 1;
16925 }
16926
16927
16928 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16929 PyObject *pyobj = 0;
16930
16931 {
16932 #if wxUSE_UNICODE
16933 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16934 #else
16935 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16936 #endif
16937 }
16938 return pyobj;
16939 }
16940
16941
16942 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16943 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16944 return 1;
16945 }
16946
16947
16948 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16949 PyObject *pyobj = 0;
16950
16951 {
16952 #if wxUSE_UNICODE
16953 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16954 #else
16955 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16956 #endif
16957 }
16958 return pyobj;
16959 }
16960
16961
16962 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16963 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16964 return 1;
16965 }
16966
16967
16968 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16969 PyObject *pyobj = 0;
16970
16971 {
16972 #if wxUSE_UNICODE
16973 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16974 #else
16975 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16976 #endif
16977 }
16978 return pyobj;
16979 }
16980
16981
16982 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16983 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16984 return 1;
16985 }
16986
16987
16988 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16989 PyObject *pyobj = 0;
16990
16991 {
16992 #if wxUSE_UNICODE
16993 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16994 #else
16995 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16996 #endif
16997 }
16998 return pyobj;
16999 }
17000
17001
17002 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17003 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17004 return 1;
17005 }
17006
17007
17008 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17009 PyObject *pyobj = 0;
17010
17011 {
17012 #if wxUSE_UNICODE
17013 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17014 #else
17015 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17016 #endif
17017 }
17018 return pyobj;
17019 }
17020
17021
17022 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17023 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17024 return 1;
17025 }
17026
17027
17028 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17029 PyObject *pyobj = 0;
17030
17031 {
17032 #if wxUSE_UNICODE
17033 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17034 #else
17035 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17036 #endif
17037 }
17038 return pyobj;
17039 }
17040
17041
17042 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17043 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17044 return 1;
17045 }
17046
17047
17048 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17049 PyObject *pyobj = 0;
17050
17051 {
17052 #if wxUSE_UNICODE
17053 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17054 #else
17055 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17056 #endif
17057 }
17058 return pyobj;
17059 }
17060
17061
17062 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17063 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17064 return 1;
17065 }
17066
17067
17068 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17069 PyObject *pyobj = 0;
17070
17071 {
17072 #if wxUSE_UNICODE
17073 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17074 #else
17075 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17076 #endif
17077 }
17078 return pyobj;
17079 }
17080
17081
17082 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17083 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17084 return 1;
17085 }
17086
17087
17088 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17089 PyObject *pyobj = 0;
17090
17091 {
17092 #if wxUSE_UNICODE
17093 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17094 #else
17095 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17096 #endif
17097 }
17098 return pyobj;
17099 }
17100
17101
17102 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17103 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17104 return 1;
17105 }
17106
17107
17108 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17109 PyObject *pyobj = 0;
17110
17111 {
17112 #if wxUSE_UNICODE
17113 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17114 #else
17115 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17116 #endif
17117 }
17118 return pyobj;
17119 }
17120
17121
17122 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17123 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17124 return 1;
17125 }
17126
17127
17128 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17129 PyObject *pyobj = 0;
17130
17131 {
17132 #if wxUSE_UNICODE
17133 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17134 #else
17135 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17136 #endif
17137 }
17138 return pyobj;
17139 }
17140
17141
17142 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17143 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17144 return 1;
17145 }
17146
17147
17148 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17149 PyObject *pyobj = 0;
17150
17151 {
17152 #if wxUSE_UNICODE
17153 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17154 #else
17155 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17156 #endif
17157 }
17158 return pyobj;
17159 }
17160
17161
17162 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17163 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17164 return 1;
17165 }
17166
17167
17168 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17169 PyObject *pyobj = 0;
17170
17171 {
17172 #if wxUSE_UNICODE
17173 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17174 #else
17175 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17176 #endif
17177 }
17178 return pyobj;
17179 }
17180
17181
17182 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17183 PyObject *resultobj = 0;
17184 wxBMPHandler *result = 0 ;
17185
17186 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17187 {
17188 PyThreadState* __tstate = wxPyBeginAllowThreads();
17189 result = (wxBMPHandler *)new wxBMPHandler();
17190 wxPyEndAllowThreads(__tstate);
17191 if (PyErr_Occurred()) SWIG_fail;
17192 }
17193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17194 return resultobj;
17195 fail:
17196 return NULL;
17197 }
17198
17199
17200 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17201 PyObject *obj;
17202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17203 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17204 return SWIG_Py_Void();
17205 }
17206
17207 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17208 return SWIG_Python_InitShadowInstance(args);
17209 }
17210
17211 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17212 PyObject *resultobj = 0;
17213 wxICOHandler *result = 0 ;
17214
17215 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17216 {
17217 PyThreadState* __tstate = wxPyBeginAllowThreads();
17218 result = (wxICOHandler *)new wxICOHandler();
17219 wxPyEndAllowThreads(__tstate);
17220 if (PyErr_Occurred()) SWIG_fail;
17221 }
17222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17223 return resultobj;
17224 fail:
17225 return NULL;
17226 }
17227
17228
17229 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17230 PyObject *obj;
17231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17232 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17233 return SWIG_Py_Void();
17234 }
17235
17236 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17237 return SWIG_Python_InitShadowInstance(args);
17238 }
17239
17240 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17241 PyObject *resultobj = 0;
17242 wxCURHandler *result = 0 ;
17243
17244 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17245 {
17246 PyThreadState* __tstate = wxPyBeginAllowThreads();
17247 result = (wxCURHandler *)new wxCURHandler();
17248 wxPyEndAllowThreads(__tstate);
17249 if (PyErr_Occurred()) SWIG_fail;
17250 }
17251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17252 return resultobj;
17253 fail:
17254 return NULL;
17255 }
17256
17257
17258 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17259 PyObject *obj;
17260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17261 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17262 return SWIG_Py_Void();
17263 }
17264
17265 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17266 return SWIG_Python_InitShadowInstance(args);
17267 }
17268
17269 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17270 PyObject *resultobj = 0;
17271 wxANIHandler *result = 0 ;
17272
17273 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17274 {
17275 PyThreadState* __tstate = wxPyBeginAllowThreads();
17276 result = (wxANIHandler *)new wxANIHandler();
17277 wxPyEndAllowThreads(__tstate);
17278 if (PyErr_Occurred()) SWIG_fail;
17279 }
17280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17281 return resultobj;
17282 fail:
17283 return NULL;
17284 }
17285
17286
17287 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17288 PyObject *obj;
17289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17290 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17291 return SWIG_Py_Void();
17292 }
17293
17294 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17295 return SWIG_Python_InitShadowInstance(args);
17296 }
17297
17298 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17299 PyObject *resultobj = 0;
17300 wxPNGHandler *result = 0 ;
17301
17302 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17303 {
17304 PyThreadState* __tstate = wxPyBeginAllowThreads();
17305 result = (wxPNGHandler *)new wxPNGHandler();
17306 wxPyEndAllowThreads(__tstate);
17307 if (PyErr_Occurred()) SWIG_fail;
17308 }
17309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17310 return resultobj;
17311 fail:
17312 return NULL;
17313 }
17314
17315
17316 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17317 PyObject *obj;
17318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17319 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17320 return SWIG_Py_Void();
17321 }
17322
17323 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17324 return SWIG_Python_InitShadowInstance(args);
17325 }
17326
17327 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17328 PyObject *resultobj = 0;
17329 wxGIFHandler *result = 0 ;
17330
17331 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17332 {
17333 PyThreadState* __tstate = wxPyBeginAllowThreads();
17334 result = (wxGIFHandler *)new wxGIFHandler();
17335 wxPyEndAllowThreads(__tstate);
17336 if (PyErr_Occurred()) SWIG_fail;
17337 }
17338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17339 return resultobj;
17340 fail:
17341 return NULL;
17342 }
17343
17344
17345 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17346 PyObject *obj;
17347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17348 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17349 return SWIG_Py_Void();
17350 }
17351
17352 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17353 return SWIG_Python_InitShadowInstance(args);
17354 }
17355
17356 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17357 PyObject *resultobj = 0;
17358 wxPCXHandler *result = 0 ;
17359
17360 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17361 {
17362 PyThreadState* __tstate = wxPyBeginAllowThreads();
17363 result = (wxPCXHandler *)new wxPCXHandler();
17364 wxPyEndAllowThreads(__tstate);
17365 if (PyErr_Occurred()) SWIG_fail;
17366 }
17367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17368 return resultobj;
17369 fail:
17370 return NULL;
17371 }
17372
17373
17374 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17375 PyObject *obj;
17376 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17377 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17378 return SWIG_Py_Void();
17379 }
17380
17381 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17382 return SWIG_Python_InitShadowInstance(args);
17383 }
17384
17385 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17386 PyObject *resultobj = 0;
17387 wxJPEGHandler *result = 0 ;
17388
17389 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17390 {
17391 PyThreadState* __tstate = wxPyBeginAllowThreads();
17392 result = (wxJPEGHandler *)new wxJPEGHandler();
17393 wxPyEndAllowThreads(__tstate);
17394 if (PyErr_Occurred()) SWIG_fail;
17395 }
17396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17404 PyObject *obj;
17405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17406 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17407 return SWIG_Py_Void();
17408 }
17409
17410 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17411 return SWIG_Python_InitShadowInstance(args);
17412 }
17413
17414 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17415 PyObject *resultobj = 0;
17416 wxPNMHandler *result = 0 ;
17417
17418 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17419 {
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = (wxPNMHandler *)new wxPNMHandler();
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17426 return resultobj;
17427 fail:
17428 return NULL;
17429 }
17430
17431
17432 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17433 PyObject *obj;
17434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17435 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17436 return SWIG_Py_Void();
17437 }
17438
17439 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17440 return SWIG_Python_InitShadowInstance(args);
17441 }
17442
17443 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17444 PyObject *resultobj = 0;
17445 wxXPMHandler *result = 0 ;
17446
17447 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17448 {
17449 PyThreadState* __tstate = wxPyBeginAllowThreads();
17450 result = (wxXPMHandler *)new wxXPMHandler();
17451 wxPyEndAllowThreads(__tstate);
17452 if (PyErr_Occurred()) SWIG_fail;
17453 }
17454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17455 return resultobj;
17456 fail:
17457 return NULL;
17458 }
17459
17460
17461 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17462 PyObject *obj;
17463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17464 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17465 return SWIG_Py_Void();
17466 }
17467
17468 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 return SWIG_Python_InitShadowInstance(args);
17470 }
17471
17472 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17473 PyObject *resultobj = 0;
17474 wxTIFFHandler *result = 0 ;
17475
17476 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17477 {
17478 PyThreadState* __tstate = wxPyBeginAllowThreads();
17479 result = (wxTIFFHandler *)new wxTIFFHandler();
17480 wxPyEndAllowThreads(__tstate);
17481 if (PyErr_Occurred()) SWIG_fail;
17482 }
17483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17484 return resultobj;
17485 fail:
17486 return NULL;
17487 }
17488
17489
17490 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491 PyObject *obj;
17492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17493 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17494 return SWIG_Py_Void();
17495 }
17496
17497 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17498 return SWIG_Python_InitShadowInstance(args);
17499 }
17500
17501 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj = 0;
17503 wxImage *arg1 = 0 ;
17504 wxImage *arg2 = 0 ;
17505 int arg3 = (int) 236 ;
17506 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17507 bool result;
17508 void *argp1 = 0 ;
17509 int res1 = 0 ;
17510 void *argp2 = 0 ;
17511 int res2 = 0 ;
17512 int val3 ;
17513 int ecode3 = 0 ;
17514 int val4 ;
17515 int ecode4 = 0 ;
17516 PyObject * obj0 = 0 ;
17517 PyObject * obj1 = 0 ;
17518 PyObject * obj2 = 0 ;
17519 PyObject * obj3 = 0 ;
17520 char * kwnames[] = {
17521 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17522 };
17523
17524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17525 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17526 if (!SWIG_IsOK(res1)) {
17527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17528 }
17529 if (!argp1) {
17530 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17531 }
17532 arg1 = reinterpret_cast< wxImage * >(argp1);
17533 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17534 if (!SWIG_IsOK(res2)) {
17535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17536 }
17537 if (!argp2) {
17538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17539 }
17540 arg2 = reinterpret_cast< wxImage * >(argp2);
17541 if (obj2) {
17542 ecode3 = SWIG_AsVal_int(obj2, &val3);
17543 if (!SWIG_IsOK(ecode3)) {
17544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17545 }
17546 arg3 = static_cast< int >(val3);
17547 }
17548 if (obj3) {
17549 ecode4 = SWIG_AsVal_int(obj3, &val4);
17550 if (!SWIG_IsOK(ecode4)) {
17551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17552 }
17553 arg4 = static_cast< int >(val4);
17554 }
17555 {
17556 PyThreadState* __tstate = wxPyBeginAllowThreads();
17557 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17558 wxPyEndAllowThreads(__tstate);
17559 if (PyErr_Occurred()) SWIG_fail;
17560 }
17561 {
17562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17563 }
17564 return resultobj;
17565 fail:
17566 return NULL;
17567 }
17568
17569
17570 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17571 PyObject *obj;
17572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17573 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17574 return SWIG_Py_Void();
17575 }
17576
17577 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17578 PyObject *resultobj = 0;
17579 wxEvtHandler *result = 0 ;
17580
17581 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 result = (wxEvtHandler *)new wxEvtHandler();
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17589 return resultobj;
17590 fail:
17591 return NULL;
17592 }
17593
17594
17595 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17596 PyObject *resultobj = 0;
17597 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17598 wxEvtHandler *result = 0 ;
17599 void *argp1 = 0 ;
17600 int res1 = 0 ;
17601 PyObject *swig_obj[1] ;
17602
17603 if (!args) SWIG_fail;
17604 swig_obj[0] = args;
17605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17606 if (!SWIG_IsOK(res1)) {
17607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17608 }
17609 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 {
17617 resultobj = wxPyMake_wxObject(result, 0);
17618 }
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17626 PyObject *resultobj = 0;
17627 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17628 wxEvtHandler *result = 0 ;
17629 void *argp1 = 0 ;
17630 int res1 = 0 ;
17631 PyObject *swig_obj[1] ;
17632
17633 if (!args) SWIG_fail;
17634 swig_obj[0] = args;
17635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17636 if (!SWIG_IsOK(res1)) {
17637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17638 }
17639 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17643 wxPyEndAllowThreads(__tstate);
17644 if (PyErr_Occurred()) SWIG_fail;
17645 }
17646 {
17647 resultobj = wxPyMake_wxObject(result, 0);
17648 }
17649 return resultobj;
17650 fail:
17651 return NULL;
17652 }
17653
17654
17655 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17656 PyObject *resultobj = 0;
17657 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17658 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17659 void *argp1 = 0 ;
17660 int res1 = 0 ;
17661 void *argp2 = 0 ;
17662 int res2 = 0 ;
17663 PyObject * obj0 = 0 ;
17664 PyObject * obj1 = 0 ;
17665 char * kwnames[] = {
17666 (char *) "self",(char *) "handler", NULL
17667 };
17668
17669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17671 if (!SWIG_IsOK(res1)) {
17672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17673 }
17674 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17675 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17676 if (!SWIG_IsOK(res2)) {
17677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17678 }
17679 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17680 {
17681 PyThreadState* __tstate = wxPyBeginAllowThreads();
17682 (arg1)->SetNextHandler(arg2);
17683 wxPyEndAllowThreads(__tstate);
17684 if (PyErr_Occurred()) SWIG_fail;
17685 }
17686 resultobj = SWIG_Py_Void();
17687 return resultobj;
17688 fail:
17689 return NULL;
17690 }
17691
17692
17693 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17694 PyObject *resultobj = 0;
17695 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17696 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17697 void *argp1 = 0 ;
17698 int res1 = 0 ;
17699 void *argp2 = 0 ;
17700 int res2 = 0 ;
17701 PyObject * obj0 = 0 ;
17702 PyObject * obj1 = 0 ;
17703 char * kwnames[] = {
17704 (char *) "self",(char *) "handler", NULL
17705 };
17706
17707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17709 if (!SWIG_IsOK(res1)) {
17710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17711 }
17712 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17714 if (!SWIG_IsOK(res2)) {
17715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17716 }
17717 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17718 {
17719 PyThreadState* __tstate = wxPyBeginAllowThreads();
17720 (arg1)->SetPreviousHandler(arg2);
17721 wxPyEndAllowThreads(__tstate);
17722 if (PyErr_Occurred()) SWIG_fail;
17723 }
17724 resultobj = SWIG_Py_Void();
17725 return resultobj;
17726 fail:
17727 return NULL;
17728 }
17729
17730
17731 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17732 PyObject *resultobj = 0;
17733 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17734 bool result;
17735 void *argp1 = 0 ;
17736 int res1 = 0 ;
17737 PyObject *swig_obj[1] ;
17738
17739 if (!args) SWIG_fail;
17740 swig_obj[0] = args;
17741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17742 if (!SWIG_IsOK(res1)) {
17743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17744 }
17745 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17746 {
17747 PyThreadState* __tstate = wxPyBeginAllowThreads();
17748 result = (bool)(arg1)->GetEvtHandlerEnabled();
17749 wxPyEndAllowThreads(__tstate);
17750 if (PyErr_Occurred()) SWIG_fail;
17751 }
17752 {
17753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17754 }
17755 return resultobj;
17756 fail:
17757 return NULL;
17758 }
17759
17760
17761 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17762 PyObject *resultobj = 0;
17763 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17764 bool arg2 ;
17765 void *argp1 = 0 ;
17766 int res1 = 0 ;
17767 bool val2 ;
17768 int ecode2 = 0 ;
17769 PyObject * obj0 = 0 ;
17770 PyObject * obj1 = 0 ;
17771 char * kwnames[] = {
17772 (char *) "self",(char *) "enabled", NULL
17773 };
17774
17775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17777 if (!SWIG_IsOK(res1)) {
17778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17779 }
17780 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17781 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17782 if (!SWIG_IsOK(ecode2)) {
17783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17784 }
17785 arg2 = static_cast< bool >(val2);
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 (arg1)->SetEvtHandlerEnabled(arg2);
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 resultobj = SWIG_Py_Void();
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj = 0;
17801 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17802 wxEvent *arg2 = 0 ;
17803 bool result;
17804 void *argp1 = 0 ;
17805 int res1 = 0 ;
17806 void *argp2 = 0 ;
17807 int res2 = 0 ;
17808 PyObject * obj0 = 0 ;
17809 PyObject * obj1 = 0 ;
17810 char * kwnames[] = {
17811 (char *) "self",(char *) "event", NULL
17812 };
17813
17814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17816 if (!SWIG_IsOK(res1)) {
17817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17818 }
17819 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17820 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17821 if (!SWIG_IsOK(res2)) {
17822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17823 }
17824 if (!argp2) {
17825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17826 }
17827 arg2 = reinterpret_cast< wxEvent * >(argp2);
17828 {
17829 PyThreadState* __tstate = wxPyBeginAllowThreads();
17830 result = (bool)(arg1)->ProcessEvent(*arg2);
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 {
17835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17836 }
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj = 0;
17845 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17846 wxEvent *arg2 = 0 ;
17847 void *argp1 = 0 ;
17848 int res1 = 0 ;
17849 void *argp2 = 0 ;
17850 int res2 = 0 ;
17851 PyObject * obj0 = 0 ;
17852 PyObject * obj1 = 0 ;
17853 char * kwnames[] = {
17854 (char *) "self",(char *) "event", NULL
17855 };
17856
17857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17859 if (!SWIG_IsOK(res1)) {
17860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17861 }
17862 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17863 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17864 if (!SWIG_IsOK(res2)) {
17865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17866 }
17867 if (!argp2) {
17868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17869 }
17870 arg2 = reinterpret_cast< wxEvent * >(argp2);
17871 {
17872 PyThreadState* __tstate = wxPyBeginAllowThreads();
17873 (arg1)->AddPendingEvent(*arg2);
17874 wxPyEndAllowThreads(__tstate);
17875 if (PyErr_Occurred()) SWIG_fail;
17876 }
17877 resultobj = SWIG_Py_Void();
17878 return resultobj;
17879 fail:
17880 return NULL;
17881 }
17882
17883
17884 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17885 PyObject *resultobj = 0;
17886 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17887 void *argp1 = 0 ;
17888 int res1 = 0 ;
17889 PyObject *swig_obj[1] ;
17890
17891 if (!args) SWIG_fail;
17892 swig_obj[0] = args;
17893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17894 if (!SWIG_IsOK(res1)) {
17895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17896 }
17897 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17898 {
17899 PyThreadState* __tstate = wxPyBeginAllowThreads();
17900 (arg1)->ProcessPendingEvents();
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 resultobj = SWIG_Py_Void();
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj = 0;
17913 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17914 int arg2 ;
17915 int arg3 ;
17916 int arg4 ;
17917 PyObject *arg5 = (PyObject *) 0 ;
17918 void *argp1 = 0 ;
17919 int res1 = 0 ;
17920 int val2 ;
17921 int ecode2 = 0 ;
17922 int val3 ;
17923 int ecode3 = 0 ;
17924 int val4 ;
17925 int ecode4 = 0 ;
17926 PyObject * obj0 = 0 ;
17927 PyObject * obj1 = 0 ;
17928 PyObject * obj2 = 0 ;
17929 PyObject * obj3 = 0 ;
17930 PyObject * obj4 = 0 ;
17931 char * kwnames[] = {
17932 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17933 };
17934
17935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17937 if (!SWIG_IsOK(res1)) {
17938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17939 }
17940 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17941 ecode2 = SWIG_AsVal_int(obj1, &val2);
17942 if (!SWIG_IsOK(ecode2)) {
17943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17944 }
17945 arg2 = static_cast< int >(val2);
17946 ecode3 = SWIG_AsVal_int(obj2, &val3);
17947 if (!SWIG_IsOK(ecode3)) {
17948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17949 }
17950 arg3 = static_cast< int >(val3);
17951 ecode4 = SWIG_AsVal_int(obj3, &val4);
17952 if (!SWIG_IsOK(ecode4)) {
17953 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17954 }
17955 arg4 = static_cast< int >(val4);
17956 arg5 = obj4;
17957 {
17958 PyThreadState* __tstate = wxPyBeginAllowThreads();
17959 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 resultobj = SWIG_Py_Void();
17964 return resultobj;
17965 fail:
17966 return NULL;
17967 }
17968
17969
17970 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17971 PyObject *resultobj = 0;
17972 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17973 int arg2 ;
17974 int arg3 = (int) -1 ;
17975 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17976 bool result;
17977 void *argp1 = 0 ;
17978 int res1 = 0 ;
17979 int val2 ;
17980 int ecode2 = 0 ;
17981 int val3 ;
17982 int ecode3 = 0 ;
17983 int val4 ;
17984 int ecode4 = 0 ;
17985 PyObject * obj0 = 0 ;
17986 PyObject * obj1 = 0 ;
17987 PyObject * obj2 = 0 ;
17988 PyObject * obj3 = 0 ;
17989 char * kwnames[] = {
17990 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17991 };
17992
17993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17995 if (!SWIG_IsOK(res1)) {
17996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17997 }
17998 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17999 ecode2 = SWIG_AsVal_int(obj1, &val2);
18000 if (!SWIG_IsOK(ecode2)) {
18001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18002 }
18003 arg2 = static_cast< int >(val2);
18004 if (obj2) {
18005 ecode3 = SWIG_AsVal_int(obj2, &val3);
18006 if (!SWIG_IsOK(ecode3)) {
18007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18008 }
18009 arg3 = static_cast< int >(val3);
18010 }
18011 if (obj3) {
18012 ecode4 = SWIG_AsVal_int(obj3, &val4);
18013 if (!SWIG_IsOK(ecode4)) {
18014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18015 }
18016 arg4 = static_cast< wxEventType >(val4);
18017 }
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 {
18025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18026 }
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj = 0;
18035 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18036 PyObject *arg2 = (PyObject *) 0 ;
18037 bool arg3 = (bool) true ;
18038 void *argp1 = 0 ;
18039 int res1 = 0 ;
18040 bool val3 ;
18041 int ecode3 = 0 ;
18042 PyObject * obj0 = 0 ;
18043 PyObject * obj1 = 0 ;
18044 PyObject * obj2 = 0 ;
18045 char * kwnames[] = {
18046 (char *) "self",(char *) "_self",(char *) "incref", NULL
18047 };
18048
18049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18051 if (!SWIG_IsOK(res1)) {
18052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18053 }
18054 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18055 arg2 = obj1;
18056 if (obj2) {
18057 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18058 if (!SWIG_IsOK(ecode3)) {
18059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18060 }
18061 arg3 = static_cast< bool >(val3);
18062 }
18063 {
18064 PyThreadState* __tstate = wxPyBeginAllowThreads();
18065 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18066 wxPyEndAllowThreads(__tstate);
18067 if (PyErr_Occurred()) SWIG_fail;
18068 }
18069 resultobj = SWIG_Py_Void();
18070 return resultobj;
18071 fail:
18072 return NULL;
18073 }
18074
18075
18076 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18077 PyObject *obj;
18078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18079 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18080 return SWIG_Py_Void();
18081 }
18082
18083 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18084 return SWIG_Python_InitShadowInstance(args);
18085 }
18086
18087 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18088 PyObject *resultobj = 0;
18089 wxEventType result;
18090
18091 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18092 {
18093 PyThreadState* __tstate = wxPyBeginAllowThreads();
18094 result = (wxEventType)wxNewEventType();
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 resultobj = SWIG_From_int(static_cast< int >(result));
18099 return resultobj;
18100 fail:
18101 return NULL;
18102 }
18103
18104
18105 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18106 PyObject *resultobj = 0;
18107 wxEvent *arg1 = (wxEvent *) 0 ;
18108 void *argp1 = 0 ;
18109 int res1 = 0 ;
18110 PyObject *swig_obj[1] ;
18111
18112 if (!args) SWIG_fail;
18113 swig_obj[0] = args;
18114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18115 if (!SWIG_IsOK(res1)) {
18116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18117 }
18118 arg1 = reinterpret_cast< wxEvent * >(argp1);
18119 {
18120 PyThreadState* __tstate = wxPyBeginAllowThreads();
18121 delete arg1;
18122
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 resultobj = SWIG_Py_Void();
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj = 0;
18135 wxEvent *arg1 = (wxEvent *) 0 ;
18136 wxEventType arg2 ;
18137 void *argp1 = 0 ;
18138 int res1 = 0 ;
18139 int val2 ;
18140 int ecode2 = 0 ;
18141 PyObject * obj0 = 0 ;
18142 PyObject * obj1 = 0 ;
18143 char * kwnames[] = {
18144 (char *) "self",(char *) "typ", NULL
18145 };
18146
18147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18149 if (!SWIG_IsOK(res1)) {
18150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18151 }
18152 arg1 = reinterpret_cast< wxEvent * >(argp1);
18153 ecode2 = SWIG_AsVal_int(obj1, &val2);
18154 if (!SWIG_IsOK(ecode2)) {
18155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18156 }
18157 arg2 = static_cast< wxEventType >(val2);
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 (arg1)->SetEventType(arg2);
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 resultobj = SWIG_Py_Void();
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18172 PyObject *resultobj = 0;
18173 wxEvent *arg1 = (wxEvent *) 0 ;
18174 wxEventType result;
18175 void *argp1 = 0 ;
18176 int res1 = 0 ;
18177 PyObject *swig_obj[1] ;
18178
18179 if (!args) SWIG_fail;
18180 swig_obj[0] = args;
18181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18184 }
18185 arg1 = reinterpret_cast< wxEvent * >(argp1);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = SWIG_From_int(static_cast< int >(result));
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18200 PyObject *resultobj = 0;
18201 wxEvent *arg1 = (wxEvent *) 0 ;
18202 wxObject *result = 0 ;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 PyObject *swig_obj[1] ;
18206
18207 if (!args) SWIG_fail;
18208 swig_obj[0] = args;
18209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18210 if (!SWIG_IsOK(res1)) {
18211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18212 }
18213 arg1 = reinterpret_cast< wxEvent * >(argp1);
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 {
18221 resultobj = wxPyMake_wxObject(result, (bool)0);
18222 }
18223 return resultobj;
18224 fail:
18225 return NULL;
18226 }
18227
18228
18229 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18230 PyObject *resultobj = 0;
18231 wxEvent *arg1 = (wxEvent *) 0 ;
18232 wxObject *arg2 = (wxObject *) 0 ;
18233 void *argp1 = 0 ;
18234 int res1 = 0 ;
18235 void *argp2 = 0 ;
18236 int res2 = 0 ;
18237 PyObject * obj0 = 0 ;
18238 PyObject * obj1 = 0 ;
18239 char * kwnames[] = {
18240 (char *) "self",(char *) "obj", NULL
18241 };
18242
18243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvent * >(argp1);
18249 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18250 if (!SWIG_IsOK(res2)) {
18251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18252 }
18253 arg2 = reinterpret_cast< wxObject * >(argp2);
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 (arg1)->SetEventObject(arg2);
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 resultobj = SWIG_Py_Void();
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18268 PyObject *resultobj = 0;
18269 wxEvent *arg1 = (wxEvent *) 0 ;
18270 long result;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 PyObject *swig_obj[1] ;
18274
18275 if (!args) SWIG_fail;
18276 swig_obj[0] = args;
18277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18278 if (!SWIG_IsOK(res1)) {
18279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18280 }
18281 arg1 = reinterpret_cast< wxEvent * >(argp1);
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 resultobj = SWIG_From_long(static_cast< long >(result));
18289 return resultobj;
18290 fail:
18291 return NULL;
18292 }
18293
18294
18295 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18296 PyObject *resultobj = 0;
18297 wxEvent *arg1 = (wxEvent *) 0 ;
18298 long arg2 = (long) 0 ;
18299 void *argp1 = 0 ;
18300 int res1 = 0 ;
18301 long val2 ;
18302 int ecode2 = 0 ;
18303 PyObject * obj0 = 0 ;
18304 PyObject * obj1 = 0 ;
18305 char * kwnames[] = {
18306 (char *) "self",(char *) "ts", NULL
18307 };
18308
18309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18311 if (!SWIG_IsOK(res1)) {
18312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18313 }
18314 arg1 = reinterpret_cast< wxEvent * >(argp1);
18315 if (obj1) {
18316 ecode2 = SWIG_AsVal_long(obj1, &val2);
18317 if (!SWIG_IsOK(ecode2)) {
18318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18319 }
18320 arg2 = static_cast< long >(val2);
18321 }
18322 {
18323 PyThreadState* __tstate = wxPyBeginAllowThreads();
18324 (arg1)->SetTimestamp(arg2);
18325 wxPyEndAllowThreads(__tstate);
18326 if (PyErr_Occurred()) SWIG_fail;
18327 }
18328 resultobj = SWIG_Py_Void();
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18336 PyObject *resultobj = 0;
18337 wxEvent *arg1 = (wxEvent *) 0 ;
18338 int result;
18339 void *argp1 = 0 ;
18340 int res1 = 0 ;
18341 PyObject *swig_obj[1] ;
18342
18343 if (!args) SWIG_fail;
18344 swig_obj[0] = args;
18345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18346 if (!SWIG_IsOK(res1)) {
18347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18348 }
18349 arg1 = reinterpret_cast< wxEvent * >(argp1);
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (int)((wxEvent const *)arg1)->GetId();
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 resultobj = SWIG_From_int(static_cast< int >(result));
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18364 PyObject *resultobj = 0;
18365 wxEvent *arg1 = (wxEvent *) 0 ;
18366 int arg2 ;
18367 void *argp1 = 0 ;
18368 int res1 = 0 ;
18369 int val2 ;
18370 int ecode2 = 0 ;
18371 PyObject * obj0 = 0 ;
18372 PyObject * obj1 = 0 ;
18373 char * kwnames[] = {
18374 (char *) "self",(char *) "Id", NULL
18375 };
18376
18377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18379 if (!SWIG_IsOK(res1)) {
18380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18381 }
18382 arg1 = reinterpret_cast< wxEvent * >(argp1);
18383 ecode2 = SWIG_AsVal_int(obj1, &val2);
18384 if (!SWIG_IsOK(ecode2)) {
18385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18386 }
18387 arg2 = static_cast< int >(val2);
18388 {
18389 PyThreadState* __tstate = wxPyBeginAllowThreads();
18390 (arg1)->SetId(arg2);
18391 wxPyEndAllowThreads(__tstate);
18392 if (PyErr_Occurred()) SWIG_fail;
18393 }
18394 resultobj = SWIG_Py_Void();
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18402 PyObject *resultobj = 0;
18403 wxEvent *arg1 = (wxEvent *) 0 ;
18404 bool result;
18405 void *argp1 = 0 ;
18406 int res1 = 0 ;
18407 PyObject *swig_obj[1] ;
18408
18409 if (!args) SWIG_fail;
18410 swig_obj[0] = args;
18411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18412 if (!SWIG_IsOK(res1)) {
18413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18414 }
18415 arg1 = reinterpret_cast< wxEvent * >(argp1);
18416 {
18417 PyThreadState* __tstate = wxPyBeginAllowThreads();
18418 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18419 wxPyEndAllowThreads(__tstate);
18420 if (PyErr_Occurred()) SWIG_fail;
18421 }
18422 {
18423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18424 }
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18432 PyObject *resultobj = 0;
18433 wxEvent *arg1 = (wxEvent *) 0 ;
18434 bool arg2 = (bool) true ;
18435 void *argp1 = 0 ;
18436 int res1 = 0 ;
18437 bool val2 ;
18438 int ecode2 = 0 ;
18439 PyObject * obj0 = 0 ;
18440 PyObject * obj1 = 0 ;
18441 char * kwnames[] = {
18442 (char *) "self",(char *) "skip", NULL
18443 };
18444
18445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18447 if (!SWIG_IsOK(res1)) {
18448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18449 }
18450 arg1 = reinterpret_cast< wxEvent * >(argp1);
18451 if (obj1) {
18452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18453 if (!SWIG_IsOK(ecode2)) {
18454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18455 }
18456 arg2 = static_cast< bool >(val2);
18457 }
18458 {
18459 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 (arg1)->Skip(arg2);
18461 wxPyEndAllowThreads(__tstate);
18462 if (PyErr_Occurred()) SWIG_fail;
18463 }
18464 resultobj = SWIG_Py_Void();
18465 return resultobj;
18466 fail:
18467 return NULL;
18468 }
18469
18470
18471 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18472 PyObject *resultobj = 0;
18473 wxEvent *arg1 = (wxEvent *) 0 ;
18474 bool result;
18475 void *argp1 = 0 ;
18476 int res1 = 0 ;
18477 PyObject *swig_obj[1] ;
18478
18479 if (!args) SWIG_fail;
18480 swig_obj[0] = args;
18481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18482 if (!SWIG_IsOK(res1)) {
18483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18484 }
18485 arg1 = reinterpret_cast< wxEvent * >(argp1);
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18489 wxPyEndAllowThreads(__tstate);
18490 if (PyErr_Occurred()) SWIG_fail;
18491 }
18492 {
18493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18494 }
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18502 PyObject *resultobj = 0;
18503 wxEvent *arg1 = (wxEvent *) 0 ;
18504 bool result;
18505 void *argp1 = 0 ;
18506 int res1 = 0 ;
18507 PyObject *swig_obj[1] ;
18508
18509 if (!args) SWIG_fail;
18510 swig_obj[0] = args;
18511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18512 if (!SWIG_IsOK(res1)) {
18513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18514 }
18515 arg1 = reinterpret_cast< wxEvent * >(argp1);
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18519 wxPyEndAllowThreads(__tstate);
18520 if (PyErr_Occurred()) SWIG_fail;
18521 }
18522 {
18523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18524 }
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18532 PyObject *resultobj = 0;
18533 wxEvent *arg1 = (wxEvent *) 0 ;
18534 int result;
18535 void *argp1 = 0 ;
18536 int res1 = 0 ;
18537 PyObject *swig_obj[1] ;
18538
18539 if (!args) SWIG_fail;
18540 swig_obj[0] = args;
18541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18542 if (!SWIG_IsOK(res1)) {
18543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18544 }
18545 arg1 = reinterpret_cast< wxEvent * >(argp1);
18546 {
18547 PyThreadState* __tstate = wxPyBeginAllowThreads();
18548 result = (int)(arg1)->StopPropagation();
18549 wxPyEndAllowThreads(__tstate);
18550 if (PyErr_Occurred()) SWIG_fail;
18551 }
18552 resultobj = SWIG_From_int(static_cast< int >(result));
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj = 0;
18561 wxEvent *arg1 = (wxEvent *) 0 ;
18562 int arg2 ;
18563 void *argp1 = 0 ;
18564 int res1 = 0 ;
18565 int val2 ;
18566 int ecode2 = 0 ;
18567 PyObject * obj0 = 0 ;
18568 PyObject * obj1 = 0 ;
18569 char * kwnames[] = {
18570 (char *) "self",(char *) "propagationLevel", NULL
18571 };
18572
18573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18577 }
18578 arg1 = reinterpret_cast< wxEvent * >(argp1);
18579 ecode2 = SWIG_AsVal_int(obj1, &val2);
18580 if (!SWIG_IsOK(ecode2)) {
18581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18582 }
18583 arg2 = static_cast< int >(val2);
18584 {
18585 PyThreadState* __tstate = wxPyBeginAllowThreads();
18586 (arg1)->ResumePropagation(arg2);
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_Py_Void();
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18598 PyObject *resultobj = 0;
18599 wxEvent *arg1 = (wxEvent *) 0 ;
18600 wxEvent *result = 0 ;
18601 void *argp1 = 0 ;
18602 int res1 = 0 ;
18603 PyObject *swig_obj[1] ;
18604
18605 if (!args) SWIG_fail;
18606 swig_obj[0] = args;
18607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18608 if (!SWIG_IsOK(res1)) {
18609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18610 }
18611 arg1 = reinterpret_cast< wxEvent * >(argp1);
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 result = (wxEvent *)(arg1)->Clone();
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18626 PyObject *obj;
18627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18628 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18629 return SWIG_Py_Void();
18630 }
18631
18632 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj = 0;
18634 wxEvent *arg1 = 0 ;
18635 wxPropagationDisabler *result = 0 ;
18636 void *argp1 = 0 ;
18637 int res1 = 0 ;
18638 PyObject * obj0 = 0 ;
18639 char * kwnames[] = {
18640 (char *) "event", NULL
18641 };
18642
18643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18644 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18645 if (!SWIG_IsOK(res1)) {
18646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18647 }
18648 if (!argp1) {
18649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18650 }
18651 arg1 = reinterpret_cast< wxEvent * >(argp1);
18652 {
18653 PyThreadState* __tstate = wxPyBeginAllowThreads();
18654 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18655 wxPyEndAllowThreads(__tstate);
18656 if (PyErr_Occurred()) SWIG_fail;
18657 }
18658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18666 PyObject *resultobj = 0;
18667 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18668 void *argp1 = 0 ;
18669 int res1 = 0 ;
18670 PyObject *swig_obj[1] ;
18671
18672 if (!args) SWIG_fail;
18673 swig_obj[0] = args;
18674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18675 if (!SWIG_IsOK(res1)) {
18676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18677 }
18678 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18679 {
18680 PyThreadState* __tstate = wxPyBeginAllowThreads();
18681 delete arg1;
18682
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 resultobj = SWIG_Py_Void();
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18694 PyObject *obj;
18695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18696 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18697 return SWIG_Py_Void();
18698 }
18699
18700 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18701 return SWIG_Python_InitShadowInstance(args);
18702 }
18703
18704 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18705 PyObject *resultobj = 0;
18706 wxEvent *arg1 = 0 ;
18707 wxPropagateOnce *result = 0 ;
18708 void *argp1 = 0 ;
18709 int res1 = 0 ;
18710 PyObject * obj0 = 0 ;
18711 char * kwnames[] = {
18712 (char *) "event", NULL
18713 };
18714
18715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18716 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18717 if (!SWIG_IsOK(res1)) {
18718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18719 }
18720 if (!argp1) {
18721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18722 }
18723 arg1 = reinterpret_cast< wxEvent * >(argp1);
18724 {
18725 PyThreadState* __tstate = wxPyBeginAllowThreads();
18726 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18731 return resultobj;
18732 fail:
18733 return NULL;
18734 }
18735
18736
18737 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18738 PyObject *resultobj = 0;
18739 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18740 void *argp1 = 0 ;
18741 int res1 = 0 ;
18742 PyObject *swig_obj[1] ;
18743
18744 if (!args) SWIG_fail;
18745 swig_obj[0] = args;
18746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18747 if (!SWIG_IsOK(res1)) {
18748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18749 }
18750 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18751 {
18752 PyThreadState* __tstate = wxPyBeginAllowThreads();
18753 delete arg1;
18754
18755 wxPyEndAllowThreads(__tstate);
18756 if (PyErr_Occurred()) SWIG_fail;
18757 }
18758 resultobj = SWIG_Py_Void();
18759 return resultobj;
18760 fail:
18761 return NULL;
18762 }
18763
18764
18765 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18766 PyObject *obj;
18767 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18768 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18769 return SWIG_Py_Void();
18770 }
18771
18772 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18773 return SWIG_Python_InitShadowInstance(args);
18774 }
18775
18776 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj = 0;
18778 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18779 int arg2 = (int) 0 ;
18780 wxCommandEvent *result = 0 ;
18781 int val1 ;
18782 int ecode1 = 0 ;
18783 int val2 ;
18784 int ecode2 = 0 ;
18785 PyObject * obj0 = 0 ;
18786 PyObject * obj1 = 0 ;
18787 char * kwnames[] = {
18788 (char *) "commandType",(char *) "winid", NULL
18789 };
18790
18791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18792 if (obj0) {
18793 ecode1 = SWIG_AsVal_int(obj0, &val1);
18794 if (!SWIG_IsOK(ecode1)) {
18795 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18796 }
18797 arg1 = static_cast< wxEventType >(val1);
18798 }
18799 if (obj1) {
18800 ecode2 = SWIG_AsVal_int(obj1, &val2);
18801 if (!SWIG_IsOK(ecode2)) {
18802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18803 }
18804 arg2 = static_cast< int >(val2);
18805 }
18806 {
18807 PyThreadState* __tstate = wxPyBeginAllowThreads();
18808 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18809 wxPyEndAllowThreads(__tstate);
18810 if (PyErr_Occurred()) SWIG_fail;
18811 }
18812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18813 return resultobj;
18814 fail:
18815 return NULL;
18816 }
18817
18818
18819 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18820 PyObject *resultobj = 0;
18821 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18822 int result;
18823 void *argp1 = 0 ;
18824 int res1 = 0 ;
18825 PyObject *swig_obj[1] ;
18826
18827 if (!args) SWIG_fail;
18828 swig_obj[0] = args;
18829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18830 if (!SWIG_IsOK(res1)) {
18831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18832 }
18833 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18837 wxPyEndAllowThreads(__tstate);
18838 if (PyErr_Occurred()) SWIG_fail;
18839 }
18840 resultobj = SWIG_From_int(static_cast< int >(result));
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18848 PyObject *resultobj = 0;
18849 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18850 wxString *arg2 = 0 ;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 bool temp2 = false ;
18854 PyObject * obj0 = 0 ;
18855 PyObject * obj1 = 0 ;
18856 char * kwnames[] = {
18857 (char *) "self",(char *) "s", NULL
18858 };
18859
18860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18862 if (!SWIG_IsOK(res1)) {
18863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18864 }
18865 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18866 {
18867 arg2 = wxString_in_helper(obj1);
18868 if (arg2 == NULL) SWIG_fail;
18869 temp2 = true;
18870 }
18871 {
18872 PyThreadState* __tstate = wxPyBeginAllowThreads();
18873 (arg1)->SetString((wxString const &)*arg2);
18874 wxPyEndAllowThreads(__tstate);
18875 if (PyErr_Occurred()) SWIG_fail;
18876 }
18877 resultobj = SWIG_Py_Void();
18878 {
18879 if (temp2)
18880 delete arg2;
18881 }
18882 return resultobj;
18883 fail:
18884 {
18885 if (temp2)
18886 delete arg2;
18887 }
18888 return NULL;
18889 }
18890
18891
18892 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18893 PyObject *resultobj = 0;
18894 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18895 wxString result;
18896 void *argp1 = 0 ;
18897 int res1 = 0 ;
18898 PyObject *swig_obj[1] ;
18899
18900 if (!args) SWIG_fail;
18901 swig_obj[0] = args;
18902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18903 if (!SWIG_IsOK(res1)) {
18904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18905 }
18906 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18907 {
18908 PyThreadState* __tstate = wxPyBeginAllowThreads();
18909 result = ((wxCommandEvent const *)arg1)->GetString();
18910 wxPyEndAllowThreads(__tstate);
18911 if (PyErr_Occurred()) SWIG_fail;
18912 }
18913 {
18914 #if wxUSE_UNICODE
18915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18916 #else
18917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18918 #endif
18919 }
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18927 PyObject *resultobj = 0;
18928 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18929 bool result;
18930 void *argp1 = 0 ;
18931 int res1 = 0 ;
18932 PyObject *swig_obj[1] ;
18933
18934 if (!args) SWIG_fail;
18935 swig_obj[0] = args;
18936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18937 if (!SWIG_IsOK(res1)) {
18938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18939 }
18940 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18941 {
18942 PyThreadState* __tstate = wxPyBeginAllowThreads();
18943 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18944 wxPyEndAllowThreads(__tstate);
18945 if (PyErr_Occurred()) SWIG_fail;
18946 }
18947 {
18948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18949 }
18950 return resultobj;
18951 fail:
18952 return NULL;
18953 }
18954
18955
18956 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18957 PyObject *resultobj = 0;
18958 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18959 bool result;
18960 void *argp1 = 0 ;
18961 int res1 = 0 ;
18962 PyObject *swig_obj[1] ;
18963
18964 if (!args) SWIG_fail;
18965 swig_obj[0] = args;
18966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18967 if (!SWIG_IsOK(res1)) {
18968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18969 }
18970 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 {
18978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18979 }
18980 return resultobj;
18981 fail:
18982 return NULL;
18983 }
18984
18985
18986 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18987 PyObject *resultobj = 0;
18988 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18989 long arg2 ;
18990 void *argp1 = 0 ;
18991 int res1 = 0 ;
18992 long val2 ;
18993 int ecode2 = 0 ;
18994 PyObject * obj0 = 0 ;
18995 PyObject * obj1 = 0 ;
18996 char * kwnames[] = {
18997 (char *) "self",(char *) "extraLong", NULL
18998 };
18999
19000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19002 if (!SWIG_IsOK(res1)) {
19003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19004 }
19005 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19006 ecode2 = SWIG_AsVal_long(obj1, &val2);
19007 if (!SWIG_IsOK(ecode2)) {
19008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19009 }
19010 arg2 = static_cast< long >(val2);
19011 {
19012 PyThreadState* __tstate = wxPyBeginAllowThreads();
19013 (arg1)->SetExtraLong(arg2);
19014 wxPyEndAllowThreads(__tstate);
19015 if (PyErr_Occurred()) SWIG_fail;
19016 }
19017 resultobj = SWIG_Py_Void();
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19025 PyObject *resultobj = 0;
19026 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19027 long result;
19028 void *argp1 = 0 ;
19029 int res1 = 0 ;
19030 PyObject *swig_obj[1] ;
19031
19032 if (!args) SWIG_fail;
19033 swig_obj[0] = args;
19034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19035 if (!SWIG_IsOK(res1)) {
19036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19037 }
19038 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19039 {
19040 PyThreadState* __tstate = wxPyBeginAllowThreads();
19041 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19042 wxPyEndAllowThreads(__tstate);
19043 if (PyErr_Occurred()) SWIG_fail;
19044 }
19045 resultobj = SWIG_From_long(static_cast< long >(result));
19046 return resultobj;
19047 fail:
19048 return NULL;
19049 }
19050
19051
19052 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19053 PyObject *resultobj = 0;
19054 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19055 int arg2 ;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 int val2 ;
19059 int ecode2 = 0 ;
19060 PyObject * obj0 = 0 ;
19061 PyObject * obj1 = 0 ;
19062 char * kwnames[] = {
19063 (char *) "self",(char *) "i", NULL
19064 };
19065
19066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19068 if (!SWIG_IsOK(res1)) {
19069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19070 }
19071 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19072 ecode2 = SWIG_AsVal_int(obj1, &val2);
19073 if (!SWIG_IsOK(ecode2)) {
19074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19075 }
19076 arg2 = static_cast< int >(val2);
19077 {
19078 PyThreadState* __tstate = wxPyBeginAllowThreads();
19079 (arg1)->SetInt(arg2);
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 resultobj = SWIG_Py_Void();
19084 return resultobj;
19085 fail:
19086 return NULL;
19087 }
19088
19089
19090 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19091 PyObject *resultobj = 0;
19092 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19093 int result;
19094 void *argp1 = 0 ;
19095 int res1 = 0 ;
19096 PyObject *swig_obj[1] ;
19097
19098 if (!args) SWIG_fail;
19099 swig_obj[0] = args;
19100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19101 if (!SWIG_IsOK(res1)) {
19102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19103 }
19104 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19105 {
19106 PyThreadState* __tstate = wxPyBeginAllowThreads();
19107 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19108 wxPyEndAllowThreads(__tstate);
19109 if (PyErr_Occurred()) SWIG_fail;
19110 }
19111 resultobj = SWIG_From_int(static_cast< int >(result));
19112 return resultobj;
19113 fail:
19114 return NULL;
19115 }
19116
19117
19118 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19119 PyObject *resultobj = 0;
19120 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19121 PyObject *result = 0 ;
19122 void *argp1 = 0 ;
19123 int res1 = 0 ;
19124 PyObject *swig_obj[1] ;
19125
19126 if (!args) SWIG_fail;
19127 swig_obj[0] = args;
19128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19129 if (!SWIG_IsOK(res1)) {
19130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19131 }
19132 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19133 {
19134 PyThreadState* __tstate = wxPyBeginAllowThreads();
19135 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19136 wxPyEndAllowThreads(__tstate);
19137 if (PyErr_Occurred()) SWIG_fail;
19138 }
19139 resultobj = result;
19140 return resultobj;
19141 fail:
19142 return NULL;
19143 }
19144
19145
19146 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19147 PyObject *resultobj = 0;
19148 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19149 PyObject *arg2 = (PyObject *) 0 ;
19150 void *argp1 = 0 ;
19151 int res1 = 0 ;
19152 PyObject * obj0 = 0 ;
19153 PyObject * obj1 = 0 ;
19154 char * kwnames[] = {
19155 (char *) "self",(char *) "clientData", NULL
19156 };
19157
19158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19160 if (!SWIG_IsOK(res1)) {
19161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19162 }
19163 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19164 arg2 = obj1;
19165 {
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 wxCommandEvent_SetClientData(arg1,arg2);
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 resultobj = SWIG_Py_Void();
19172 return resultobj;
19173 fail:
19174 return NULL;
19175 }
19176
19177
19178 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19179 PyObject *resultobj = 0;
19180 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19181 wxEvent *result = 0 ;
19182 void *argp1 = 0 ;
19183 int res1 = 0 ;
19184 PyObject *swig_obj[1] ;
19185
19186 if (!args) SWIG_fail;
19187 swig_obj[0] = args;
19188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19189 if (!SWIG_IsOK(res1)) {
19190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19191 }
19192 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19193 {
19194 PyThreadState* __tstate = wxPyBeginAllowThreads();
19195 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19207 PyObject *obj;
19208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19209 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19210 return SWIG_Py_Void();
19211 }
19212
19213 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19214 return SWIG_Python_InitShadowInstance(args);
19215 }
19216
19217 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19218 PyObject *resultobj = 0;
19219 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19220 int arg2 = (int) 0 ;
19221 wxNotifyEvent *result = 0 ;
19222 int val1 ;
19223 int ecode1 = 0 ;
19224 int val2 ;
19225 int ecode2 = 0 ;
19226 PyObject * obj0 = 0 ;
19227 PyObject * obj1 = 0 ;
19228 char * kwnames[] = {
19229 (char *) "commandType",(char *) "winid", NULL
19230 };
19231
19232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19233 if (obj0) {
19234 ecode1 = SWIG_AsVal_int(obj0, &val1);
19235 if (!SWIG_IsOK(ecode1)) {
19236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19237 }
19238 arg1 = static_cast< wxEventType >(val1);
19239 }
19240 if (obj1) {
19241 ecode2 = SWIG_AsVal_int(obj1, &val2);
19242 if (!SWIG_IsOK(ecode2)) {
19243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19244 }
19245 arg2 = static_cast< int >(val2);
19246 }
19247 {
19248 PyThreadState* __tstate = wxPyBeginAllowThreads();
19249 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19250 wxPyEndAllowThreads(__tstate);
19251 if (PyErr_Occurred()) SWIG_fail;
19252 }
19253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19254 return resultobj;
19255 fail:
19256 return NULL;
19257 }
19258
19259
19260 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19261 PyObject *resultobj = 0;
19262 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19263 void *argp1 = 0 ;
19264 int res1 = 0 ;
19265 PyObject *swig_obj[1] ;
19266
19267 if (!args) SWIG_fail;
19268 swig_obj[0] = args;
19269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19270 if (!SWIG_IsOK(res1)) {
19271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19272 }
19273 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19274 {
19275 PyThreadState* __tstate = wxPyBeginAllowThreads();
19276 (arg1)->Veto();
19277 wxPyEndAllowThreads(__tstate);
19278 if (PyErr_Occurred()) SWIG_fail;
19279 }
19280 resultobj = SWIG_Py_Void();
19281 return resultobj;
19282 fail:
19283 return NULL;
19284 }
19285
19286
19287 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19288 PyObject *resultobj = 0;
19289 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19290 void *argp1 = 0 ;
19291 int res1 = 0 ;
19292 PyObject *swig_obj[1] ;
19293
19294 if (!args) SWIG_fail;
19295 swig_obj[0] = args;
19296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19297 if (!SWIG_IsOK(res1)) {
19298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19299 }
19300 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19301 {
19302 PyThreadState* __tstate = wxPyBeginAllowThreads();
19303 (arg1)->Allow();
19304 wxPyEndAllowThreads(__tstate);
19305 if (PyErr_Occurred()) SWIG_fail;
19306 }
19307 resultobj = SWIG_Py_Void();
19308 return resultobj;
19309 fail:
19310 return NULL;
19311 }
19312
19313
19314 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19315 PyObject *resultobj = 0;
19316 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19317 bool result;
19318 void *argp1 = 0 ;
19319 int res1 = 0 ;
19320 PyObject *swig_obj[1] ;
19321
19322 if (!args) SWIG_fail;
19323 swig_obj[0] = args;
19324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19325 if (!SWIG_IsOK(res1)) {
19326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19327 }
19328 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19329 {
19330 PyThreadState* __tstate = wxPyBeginAllowThreads();
19331 result = (bool)(arg1)->IsAllowed();
19332 wxPyEndAllowThreads(__tstate);
19333 if (PyErr_Occurred()) SWIG_fail;
19334 }
19335 {
19336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19337 }
19338 return resultobj;
19339 fail:
19340 return NULL;
19341 }
19342
19343
19344 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19345 PyObject *obj;
19346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19347 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19348 return SWIG_Py_Void();
19349 }
19350
19351 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19352 return SWIG_Python_InitShadowInstance(args);
19353 }
19354
19355 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19356 PyObject *resultobj = 0;
19357 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19358 int arg2 = (int) 0 ;
19359 int arg3 = (int) 0 ;
19360 int arg4 = (int) 0 ;
19361 wxScrollEvent *result = 0 ;
19362 int val1 ;
19363 int ecode1 = 0 ;
19364 int val2 ;
19365 int ecode2 = 0 ;
19366 int val3 ;
19367 int ecode3 = 0 ;
19368 int val4 ;
19369 int ecode4 = 0 ;
19370 PyObject * obj0 = 0 ;
19371 PyObject * obj1 = 0 ;
19372 PyObject * obj2 = 0 ;
19373 PyObject * obj3 = 0 ;
19374 char * kwnames[] = {
19375 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19376 };
19377
19378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19379 if (obj0) {
19380 ecode1 = SWIG_AsVal_int(obj0, &val1);
19381 if (!SWIG_IsOK(ecode1)) {
19382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19383 }
19384 arg1 = static_cast< wxEventType >(val1);
19385 }
19386 if (obj1) {
19387 ecode2 = SWIG_AsVal_int(obj1, &val2);
19388 if (!SWIG_IsOK(ecode2)) {
19389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19390 }
19391 arg2 = static_cast< int >(val2);
19392 }
19393 if (obj2) {
19394 ecode3 = SWIG_AsVal_int(obj2, &val3);
19395 if (!SWIG_IsOK(ecode3)) {
19396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19397 }
19398 arg3 = static_cast< int >(val3);
19399 }
19400 if (obj3) {
19401 ecode4 = SWIG_AsVal_int(obj3, &val4);
19402 if (!SWIG_IsOK(ecode4)) {
19403 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19404 }
19405 arg4 = static_cast< int >(val4);
19406 }
19407 {
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19414 return resultobj;
19415 fail:
19416 return NULL;
19417 }
19418
19419
19420 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19421 PyObject *resultobj = 0;
19422 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19423 int result;
19424 void *argp1 = 0 ;
19425 int res1 = 0 ;
19426 PyObject *swig_obj[1] ;
19427
19428 if (!args) SWIG_fail;
19429 swig_obj[0] = args;
19430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19431 if (!SWIG_IsOK(res1)) {
19432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19433 }
19434 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19435 {
19436 PyThreadState* __tstate = wxPyBeginAllowThreads();
19437 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 resultobj = SWIG_From_int(static_cast< int >(result));
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19449 PyObject *resultobj = 0;
19450 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19451 int result;
19452 void *argp1 = 0 ;
19453 int res1 = 0 ;
19454 PyObject *swig_obj[1] ;
19455
19456 if (!args) SWIG_fail;
19457 swig_obj[0] = args;
19458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19459 if (!SWIG_IsOK(res1)) {
19460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19461 }
19462 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 resultobj = SWIG_From_int(static_cast< int >(result));
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19477 PyObject *resultobj = 0;
19478 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19479 int arg2 ;
19480 void *argp1 = 0 ;
19481 int res1 = 0 ;
19482 int val2 ;
19483 int ecode2 = 0 ;
19484 PyObject * obj0 = 0 ;
19485 PyObject * obj1 = 0 ;
19486 char * kwnames[] = {
19487 (char *) "self",(char *) "orient", NULL
19488 };
19489
19490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19492 if (!SWIG_IsOK(res1)) {
19493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19494 }
19495 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19496 ecode2 = SWIG_AsVal_int(obj1, &val2);
19497 if (!SWIG_IsOK(ecode2)) {
19498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19499 }
19500 arg2 = static_cast< int >(val2);
19501 {
19502 PyThreadState* __tstate = wxPyBeginAllowThreads();
19503 (arg1)->SetOrientation(arg2);
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 resultobj = SWIG_Py_Void();
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19515 PyObject *resultobj = 0;
19516 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19517 int arg2 ;
19518 void *argp1 = 0 ;
19519 int res1 = 0 ;
19520 int val2 ;
19521 int ecode2 = 0 ;
19522 PyObject * obj0 = 0 ;
19523 PyObject * obj1 = 0 ;
19524 char * kwnames[] = {
19525 (char *) "self",(char *) "pos", NULL
19526 };
19527
19528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19530 if (!SWIG_IsOK(res1)) {
19531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19532 }
19533 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19534 ecode2 = SWIG_AsVal_int(obj1, &val2);
19535 if (!SWIG_IsOK(ecode2)) {
19536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19537 }
19538 arg2 = static_cast< int >(val2);
19539 {
19540 PyThreadState* __tstate = wxPyBeginAllowThreads();
19541 (arg1)->SetPosition(arg2);
19542 wxPyEndAllowThreads(__tstate);
19543 if (PyErr_Occurred()) SWIG_fail;
19544 }
19545 resultobj = SWIG_Py_Void();
19546 return resultobj;
19547 fail:
19548 return NULL;
19549 }
19550
19551
19552 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19553 PyObject *obj;
19554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19555 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19556 return SWIG_Py_Void();
19557 }
19558
19559 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19560 return SWIG_Python_InitShadowInstance(args);
19561 }
19562
19563 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj = 0;
19565 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19566 int arg2 = (int) 0 ;
19567 int arg3 = (int) 0 ;
19568 wxScrollWinEvent *result = 0 ;
19569 int val1 ;
19570 int ecode1 = 0 ;
19571 int val2 ;
19572 int ecode2 = 0 ;
19573 int val3 ;
19574 int ecode3 = 0 ;
19575 PyObject * obj0 = 0 ;
19576 PyObject * obj1 = 0 ;
19577 PyObject * obj2 = 0 ;
19578 char * kwnames[] = {
19579 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19580 };
19581
19582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19583 if (obj0) {
19584 ecode1 = SWIG_AsVal_int(obj0, &val1);
19585 if (!SWIG_IsOK(ecode1)) {
19586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19587 }
19588 arg1 = static_cast< wxEventType >(val1);
19589 }
19590 if (obj1) {
19591 ecode2 = SWIG_AsVal_int(obj1, &val2);
19592 if (!SWIG_IsOK(ecode2)) {
19593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19594 }
19595 arg2 = static_cast< int >(val2);
19596 }
19597 if (obj2) {
19598 ecode3 = SWIG_AsVal_int(obj2, &val3);
19599 if (!SWIG_IsOK(ecode3)) {
19600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19601 }
19602 arg3 = static_cast< int >(val3);
19603 }
19604 {
19605 PyThreadState* __tstate = wxPyBeginAllowThreads();
19606 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19607 wxPyEndAllowThreads(__tstate);
19608 if (PyErr_Occurred()) SWIG_fail;
19609 }
19610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19611 return resultobj;
19612 fail:
19613 return NULL;
19614 }
19615
19616
19617 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19618 PyObject *resultobj = 0;
19619 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19620 int result;
19621 void *argp1 = 0 ;
19622 int res1 = 0 ;
19623 PyObject *swig_obj[1] ;
19624
19625 if (!args) SWIG_fail;
19626 swig_obj[0] = args;
19627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19628 if (!SWIG_IsOK(res1)) {
19629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19630 }
19631 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19632 {
19633 PyThreadState* __tstate = wxPyBeginAllowThreads();
19634 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19635 wxPyEndAllowThreads(__tstate);
19636 if (PyErr_Occurred()) SWIG_fail;
19637 }
19638 resultobj = SWIG_From_int(static_cast< int >(result));
19639 return resultobj;
19640 fail:
19641 return NULL;
19642 }
19643
19644
19645 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19646 PyObject *resultobj = 0;
19647 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19648 int result;
19649 void *argp1 = 0 ;
19650 int res1 = 0 ;
19651 PyObject *swig_obj[1] ;
19652
19653 if (!args) SWIG_fail;
19654 swig_obj[0] = args;
19655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19656 if (!SWIG_IsOK(res1)) {
19657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19658 }
19659 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19663 wxPyEndAllowThreads(__tstate);
19664 if (PyErr_Occurred()) SWIG_fail;
19665 }
19666 resultobj = SWIG_From_int(static_cast< int >(result));
19667 return resultobj;
19668 fail:
19669 return NULL;
19670 }
19671
19672
19673 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19674 PyObject *resultobj = 0;
19675 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19676 int arg2 ;
19677 void *argp1 = 0 ;
19678 int res1 = 0 ;
19679 int val2 ;
19680 int ecode2 = 0 ;
19681 PyObject * obj0 = 0 ;
19682 PyObject * obj1 = 0 ;
19683 char * kwnames[] = {
19684 (char *) "self",(char *) "orient", NULL
19685 };
19686
19687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19689 if (!SWIG_IsOK(res1)) {
19690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19691 }
19692 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19693 ecode2 = SWIG_AsVal_int(obj1, &val2);
19694 if (!SWIG_IsOK(ecode2)) {
19695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19696 }
19697 arg2 = static_cast< int >(val2);
19698 {
19699 PyThreadState* __tstate = wxPyBeginAllowThreads();
19700 (arg1)->SetOrientation(arg2);
19701 wxPyEndAllowThreads(__tstate);
19702 if (PyErr_Occurred()) SWIG_fail;
19703 }
19704 resultobj = SWIG_Py_Void();
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19712 PyObject *resultobj = 0;
19713 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19714 int arg2 ;
19715 void *argp1 = 0 ;
19716 int res1 = 0 ;
19717 int val2 ;
19718 int ecode2 = 0 ;
19719 PyObject * obj0 = 0 ;
19720 PyObject * obj1 = 0 ;
19721 char * kwnames[] = {
19722 (char *) "self",(char *) "pos", NULL
19723 };
19724
19725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19727 if (!SWIG_IsOK(res1)) {
19728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19729 }
19730 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19731 ecode2 = SWIG_AsVal_int(obj1, &val2);
19732 if (!SWIG_IsOK(ecode2)) {
19733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19734 }
19735 arg2 = static_cast< int >(val2);
19736 {
19737 PyThreadState* __tstate = wxPyBeginAllowThreads();
19738 (arg1)->SetPosition(arg2);
19739 wxPyEndAllowThreads(__tstate);
19740 if (PyErr_Occurred()) SWIG_fail;
19741 }
19742 resultobj = SWIG_Py_Void();
19743 return resultobj;
19744 fail:
19745 return NULL;
19746 }
19747
19748
19749 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19750 PyObject *obj;
19751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19752 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19753 return SWIG_Py_Void();
19754 }
19755
19756 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 return SWIG_Python_InitShadowInstance(args);
19758 }
19759
19760 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19761 PyObject *resultobj = 0;
19762 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19763 wxMouseEvent *result = 0 ;
19764 int val1 ;
19765 int ecode1 = 0 ;
19766 PyObject * obj0 = 0 ;
19767 char * kwnames[] = {
19768 (char *) "mouseType", NULL
19769 };
19770
19771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19772 if (obj0) {
19773 ecode1 = SWIG_AsVal_int(obj0, &val1);
19774 if (!SWIG_IsOK(ecode1)) {
19775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19776 }
19777 arg1 = static_cast< wxEventType >(val1);
19778 }
19779 {
19780 PyThreadState* __tstate = wxPyBeginAllowThreads();
19781 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19782 wxPyEndAllowThreads(__tstate);
19783 if (PyErr_Occurred()) SWIG_fail;
19784 }
19785 {
19786 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19787 }
19788 return resultobj;
19789 fail:
19790 return NULL;
19791 }
19792
19793
19794 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19795 PyObject *resultobj = 0;
19796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19797 bool result;
19798 void *argp1 = 0 ;
19799 int res1 = 0 ;
19800 PyObject *swig_obj[1] ;
19801
19802 if (!args) SWIG_fail;
19803 swig_obj[0] = args;
19804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19805 if (!SWIG_IsOK(res1)) {
19806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19807 }
19808 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 {
19816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19817 }
19818 return resultobj;
19819 fail:
19820 return NULL;
19821 }
19822
19823
19824 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19825 PyObject *resultobj = 0;
19826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19827 int arg2 = (int) wxMOUSE_BTN_ANY ;
19828 bool result;
19829 void *argp1 = 0 ;
19830 int res1 = 0 ;
19831 int val2 ;
19832 int ecode2 = 0 ;
19833 PyObject * obj0 = 0 ;
19834 PyObject * obj1 = 0 ;
19835 char * kwnames[] = {
19836 (char *) "self",(char *) "but", NULL
19837 };
19838
19839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19841 if (!SWIG_IsOK(res1)) {
19842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19843 }
19844 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19845 if (obj1) {
19846 ecode2 = SWIG_AsVal_int(obj1, &val2);
19847 if (!SWIG_IsOK(ecode2)) {
19848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19849 }
19850 arg2 = static_cast< int >(val2);
19851 }
19852 {
19853 PyThreadState* __tstate = wxPyBeginAllowThreads();
19854 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19855 wxPyEndAllowThreads(__tstate);
19856 if (PyErr_Occurred()) SWIG_fail;
19857 }
19858 {
19859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19860 }
19861 return resultobj;
19862 fail:
19863 return NULL;
19864 }
19865
19866
19867 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19868 PyObject *resultobj = 0;
19869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19870 int arg2 = (int) wxMOUSE_BTN_ANY ;
19871 bool result;
19872 void *argp1 = 0 ;
19873 int res1 = 0 ;
19874 int val2 ;
19875 int ecode2 = 0 ;
19876 PyObject * obj0 = 0 ;
19877 PyObject * obj1 = 0 ;
19878 char * kwnames[] = {
19879 (char *) "self",(char *) "but", NULL
19880 };
19881
19882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19884 if (!SWIG_IsOK(res1)) {
19885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19886 }
19887 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19888 if (obj1) {
19889 ecode2 = SWIG_AsVal_int(obj1, &val2);
19890 if (!SWIG_IsOK(ecode2)) {
19891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19892 }
19893 arg2 = static_cast< int >(val2);
19894 }
19895 {
19896 PyThreadState* __tstate = wxPyBeginAllowThreads();
19897 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19898 wxPyEndAllowThreads(__tstate);
19899 if (PyErr_Occurred()) SWIG_fail;
19900 }
19901 {
19902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19903 }
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19911 PyObject *resultobj = 0;
19912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19913 int arg2 = (int) wxMOUSE_BTN_ANY ;
19914 bool result;
19915 void *argp1 = 0 ;
19916 int res1 = 0 ;
19917 int val2 ;
19918 int ecode2 = 0 ;
19919 PyObject * obj0 = 0 ;
19920 PyObject * obj1 = 0 ;
19921 char * kwnames[] = {
19922 (char *) "self",(char *) "but", NULL
19923 };
19924
19925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19927 if (!SWIG_IsOK(res1)) {
19928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19929 }
19930 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19931 if (obj1) {
19932 ecode2 = SWIG_AsVal_int(obj1, &val2);
19933 if (!SWIG_IsOK(ecode2)) {
19934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19935 }
19936 arg2 = static_cast< int >(val2);
19937 }
19938 {
19939 PyThreadState* __tstate = wxPyBeginAllowThreads();
19940 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19941 wxPyEndAllowThreads(__tstate);
19942 if (PyErr_Occurred()) SWIG_fail;
19943 }
19944 {
19945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19946 }
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19954 PyObject *resultobj = 0;
19955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19956 int arg2 ;
19957 bool result;
19958 void *argp1 = 0 ;
19959 int res1 = 0 ;
19960 int val2 ;
19961 int ecode2 = 0 ;
19962 PyObject * obj0 = 0 ;
19963 PyObject * obj1 = 0 ;
19964 char * kwnames[] = {
19965 (char *) "self",(char *) "button", NULL
19966 };
19967
19968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19970 if (!SWIG_IsOK(res1)) {
19971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19972 }
19973 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19974 ecode2 = SWIG_AsVal_int(obj1, &val2);
19975 if (!SWIG_IsOK(ecode2)) {
19976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19977 }
19978 arg2 = static_cast< int >(val2);
19979 {
19980 PyThreadState* __tstate = wxPyBeginAllowThreads();
19981 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19982 wxPyEndAllowThreads(__tstate);
19983 if (PyErr_Occurred()) SWIG_fail;
19984 }
19985 {
19986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19987 }
19988 return resultobj;
19989 fail:
19990 return NULL;
19991 }
19992
19993
19994 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19995 PyObject *resultobj = 0;
19996 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19997 int arg2 ;
19998 bool result;
19999 void *argp1 = 0 ;
20000 int res1 = 0 ;
20001 int val2 ;
20002 int ecode2 = 0 ;
20003 PyObject * obj0 = 0 ;
20004 PyObject * obj1 = 0 ;
20005 char * kwnames[] = {
20006 (char *) "self",(char *) "but", NULL
20007 };
20008
20009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20011 if (!SWIG_IsOK(res1)) {
20012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20013 }
20014 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20015 ecode2 = SWIG_AsVal_int(obj1, &val2);
20016 if (!SWIG_IsOK(ecode2)) {
20017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20018 }
20019 arg2 = static_cast< int >(val2);
20020 {
20021 PyThreadState* __tstate = wxPyBeginAllowThreads();
20022 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20023 wxPyEndAllowThreads(__tstate);
20024 if (PyErr_Occurred()) SWIG_fail;
20025 }
20026 {
20027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20028 }
20029 return resultobj;
20030 fail:
20031 return NULL;
20032 }
20033
20034
20035 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20036 PyObject *resultobj = 0;
20037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20038 int result;
20039 void *argp1 = 0 ;
20040 int res1 = 0 ;
20041 PyObject *swig_obj[1] ;
20042
20043 if (!args) SWIG_fail;
20044 swig_obj[0] = args;
20045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20046 if (!SWIG_IsOK(res1)) {
20047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20048 }
20049 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20053 wxPyEndAllowThreads(__tstate);
20054 if (PyErr_Occurred()) SWIG_fail;
20055 }
20056 resultobj = SWIG_From_int(static_cast< int >(result));
20057 return resultobj;
20058 fail:
20059 return NULL;
20060 }
20061
20062
20063 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20064 PyObject *resultobj = 0;
20065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20066 bool result;
20067 void *argp1 = 0 ;
20068 int res1 = 0 ;
20069 PyObject *swig_obj[1] ;
20070
20071 if (!args) SWIG_fail;
20072 swig_obj[0] = args;
20073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20074 if (!SWIG_IsOK(res1)) {
20075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20076 }
20077 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20078 {
20079 PyThreadState* __tstate = wxPyBeginAllowThreads();
20080 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20081 wxPyEndAllowThreads(__tstate);
20082 if (PyErr_Occurred()) SWIG_fail;
20083 }
20084 {
20085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20086 }
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20094 PyObject *resultobj = 0;
20095 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20096 bool result;
20097 void *argp1 = 0 ;
20098 int res1 = 0 ;
20099 PyObject *swig_obj[1] ;
20100
20101 if (!args) SWIG_fail;
20102 swig_obj[0] = args;
20103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20104 if (!SWIG_IsOK(res1)) {
20105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20106 }
20107 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20108 {
20109 PyThreadState* __tstate = wxPyBeginAllowThreads();
20110 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 {
20115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20116 }
20117 return resultobj;
20118 fail:
20119 return NULL;
20120 }
20121
20122
20123 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20124 PyObject *resultobj = 0;
20125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20126 bool result;
20127 void *argp1 = 0 ;
20128 int res1 = 0 ;
20129 PyObject *swig_obj[1] ;
20130
20131 if (!args) SWIG_fail;
20132 swig_obj[0] = args;
20133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20134 if (!SWIG_IsOK(res1)) {
20135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20136 }
20137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20138 {
20139 PyThreadState* __tstate = wxPyBeginAllowThreads();
20140 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20141 wxPyEndAllowThreads(__tstate);
20142 if (PyErr_Occurred()) SWIG_fail;
20143 }
20144 {
20145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20146 }
20147 return resultobj;
20148 fail:
20149 return NULL;
20150 }
20151
20152
20153 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20154 PyObject *resultobj = 0;
20155 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20156 bool result;
20157 void *argp1 = 0 ;
20158 int res1 = 0 ;
20159 PyObject *swig_obj[1] ;
20160
20161 if (!args) SWIG_fail;
20162 swig_obj[0] = args;
20163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20164 if (!SWIG_IsOK(res1)) {
20165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20166 }
20167 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20168 {
20169 PyThreadState* __tstate = wxPyBeginAllowThreads();
20170 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20171 wxPyEndAllowThreads(__tstate);
20172 if (PyErr_Occurred()) SWIG_fail;
20173 }
20174 {
20175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20176 }
20177 return resultobj;
20178 fail:
20179 return NULL;
20180 }
20181
20182
20183 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20184 PyObject *resultobj = 0;
20185 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20186 bool result;
20187 void *argp1 = 0 ;
20188 int res1 = 0 ;
20189 PyObject *swig_obj[1] ;
20190
20191 if (!args) SWIG_fail;
20192 swig_obj[0] = args;
20193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20194 if (!SWIG_IsOK(res1)) {
20195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20196 }
20197 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20198 {
20199 PyThreadState* __tstate = wxPyBeginAllowThreads();
20200 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 {
20205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20206 }
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20214 PyObject *resultobj = 0;
20215 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20216 bool result;
20217 void *argp1 = 0 ;
20218 int res1 = 0 ;
20219 PyObject *swig_obj[1] ;
20220
20221 if (!args) SWIG_fail;
20222 swig_obj[0] = args;
20223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20224 if (!SWIG_IsOK(res1)) {
20225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20226 }
20227 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20228 {
20229 PyThreadState* __tstate = wxPyBeginAllowThreads();
20230 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20231 wxPyEndAllowThreads(__tstate);
20232 if (PyErr_Occurred()) SWIG_fail;
20233 }
20234 {
20235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20236 }
20237 return resultobj;
20238 fail:
20239 return NULL;
20240 }
20241
20242
20243 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20244 PyObject *resultobj = 0;
20245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20246 bool result;
20247 void *argp1 = 0 ;
20248 int res1 = 0 ;
20249 PyObject *swig_obj[1] ;
20250
20251 if (!args) SWIG_fail;
20252 swig_obj[0] = args;
20253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20254 if (!SWIG_IsOK(res1)) {
20255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20256 }
20257 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20258 {
20259 PyThreadState* __tstate = wxPyBeginAllowThreads();
20260 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20261 wxPyEndAllowThreads(__tstate);
20262 if (PyErr_Occurred()) SWIG_fail;
20263 }
20264 {
20265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20266 }
20267 return resultobj;
20268 fail:
20269 return NULL;
20270 }
20271
20272
20273 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20274 PyObject *resultobj = 0;
20275 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20276 bool result;
20277 void *argp1 = 0 ;
20278 int res1 = 0 ;
20279 PyObject *swig_obj[1] ;
20280
20281 if (!args) SWIG_fail;
20282 swig_obj[0] = args;
20283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20284 if (!SWIG_IsOK(res1)) {
20285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20286 }
20287 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 {
20295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20296 }
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20304 PyObject *resultobj = 0;
20305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20306 bool result;
20307 void *argp1 = 0 ;
20308 int res1 = 0 ;
20309 PyObject *swig_obj[1] ;
20310
20311 if (!args) SWIG_fail;
20312 swig_obj[0] = args;
20313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20314 if (!SWIG_IsOK(res1)) {
20315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20316 }
20317 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20318 {
20319 PyThreadState* __tstate = wxPyBeginAllowThreads();
20320 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20321 wxPyEndAllowThreads(__tstate);
20322 if (PyErr_Occurred()) SWIG_fail;
20323 }
20324 {
20325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20326 }
20327 return resultobj;
20328 fail:
20329 return NULL;
20330 }
20331
20332
20333 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20334 PyObject *resultobj = 0;
20335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20336 bool result;
20337 void *argp1 = 0 ;
20338 int res1 = 0 ;
20339 PyObject *swig_obj[1] ;
20340
20341 if (!args) SWIG_fail;
20342 swig_obj[0] = args;
20343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20344 if (!SWIG_IsOK(res1)) {
20345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20346 }
20347 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20351 wxPyEndAllowThreads(__tstate);
20352 if (PyErr_Occurred()) SWIG_fail;
20353 }
20354 {
20355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20356 }
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20364 PyObject *resultobj = 0;
20365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20366 bool result;
20367 void *argp1 = 0 ;
20368 int res1 = 0 ;
20369 PyObject *swig_obj[1] ;
20370
20371 if (!args) SWIG_fail;
20372 swig_obj[0] = args;
20373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20374 if (!SWIG_IsOK(res1)) {
20375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20376 }
20377 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20378 {
20379 PyThreadState* __tstate = wxPyBeginAllowThreads();
20380 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 {
20385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20386 }
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20394 PyObject *resultobj = 0;
20395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20396 bool result;
20397 void *argp1 = 0 ;
20398 int res1 = 0 ;
20399 PyObject *swig_obj[1] ;
20400
20401 if (!args) SWIG_fail;
20402 swig_obj[0] = args;
20403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20404 if (!SWIG_IsOK(res1)) {
20405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20406 }
20407 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 {
20415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20416 }
20417 return resultobj;
20418 fail:
20419 return NULL;
20420 }
20421
20422
20423 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20424 PyObject *resultobj = 0;
20425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20426 bool result;
20427 void *argp1 = 0 ;
20428 int res1 = 0 ;
20429 PyObject *swig_obj[1] ;
20430
20431 if (!args) SWIG_fail;
20432 swig_obj[0] = args;
20433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20434 if (!SWIG_IsOK(res1)) {
20435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20436 }
20437 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20438 {
20439 PyThreadState* __tstate = wxPyBeginAllowThreads();
20440 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20441 wxPyEndAllowThreads(__tstate);
20442 if (PyErr_Occurred()) SWIG_fail;
20443 }
20444 {
20445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20446 }
20447 return resultobj;
20448 fail:
20449 return NULL;
20450 }
20451
20452
20453 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20454 PyObject *resultobj = 0;
20455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20456 bool result;
20457 void *argp1 = 0 ;
20458 int res1 = 0 ;
20459 PyObject *swig_obj[1] ;
20460
20461 if (!args) SWIG_fail;
20462 swig_obj[0] = args;
20463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20464 if (!SWIG_IsOK(res1)) {
20465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20466 }
20467 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20468 {
20469 PyThreadState* __tstate = wxPyBeginAllowThreads();
20470 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20471 wxPyEndAllowThreads(__tstate);
20472 if (PyErr_Occurred()) SWIG_fail;
20473 }
20474 {
20475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20476 }
20477 return resultobj;
20478 fail:
20479 return NULL;
20480 }
20481
20482
20483 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20484 PyObject *resultobj = 0;
20485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20486 bool result;
20487 void *argp1 = 0 ;
20488 int res1 = 0 ;
20489 PyObject *swig_obj[1] ;
20490
20491 if (!args) SWIG_fail;
20492 swig_obj[0] = args;
20493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20494 if (!SWIG_IsOK(res1)) {
20495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20496 }
20497 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (bool)(arg1)->LeftIsDown();
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 {
20505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20506 }
20507 return resultobj;
20508 fail:
20509 return NULL;
20510 }
20511
20512
20513 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20514 PyObject *resultobj = 0;
20515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20516 bool result;
20517 void *argp1 = 0 ;
20518 int res1 = 0 ;
20519 PyObject *swig_obj[1] ;
20520
20521 if (!args) SWIG_fail;
20522 swig_obj[0] = args;
20523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20524 if (!SWIG_IsOK(res1)) {
20525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20526 }
20527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 result = (bool)(arg1)->MiddleIsDown();
20531 wxPyEndAllowThreads(__tstate);
20532 if (PyErr_Occurred()) SWIG_fail;
20533 }
20534 {
20535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20536 }
20537 return resultobj;
20538 fail:
20539 return NULL;
20540 }
20541
20542
20543 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20544 PyObject *resultobj = 0;
20545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20546 bool result;
20547 void *argp1 = 0 ;
20548 int res1 = 0 ;
20549 PyObject *swig_obj[1] ;
20550
20551 if (!args) SWIG_fail;
20552 swig_obj[0] = args;
20553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20554 if (!SWIG_IsOK(res1)) {
20555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20556 }
20557 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20558 {
20559 PyThreadState* __tstate = wxPyBeginAllowThreads();
20560 result = (bool)(arg1)->RightIsDown();
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 {
20565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20566 }
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20574 PyObject *resultobj = 0;
20575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20576 bool result;
20577 void *argp1 = 0 ;
20578 int res1 = 0 ;
20579 PyObject *swig_obj[1] ;
20580
20581 if (!args) SWIG_fail;
20582 swig_obj[0] = args;
20583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20584 if (!SWIG_IsOK(res1)) {
20585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20586 }
20587 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20591 wxPyEndAllowThreads(__tstate);
20592 if (PyErr_Occurred()) SWIG_fail;
20593 }
20594 {
20595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20596 }
20597 return resultobj;
20598 fail:
20599 return NULL;
20600 }
20601
20602
20603 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20604 PyObject *resultobj = 0;
20605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20606 bool result;
20607 void *argp1 = 0 ;
20608 int res1 = 0 ;
20609 PyObject *swig_obj[1] ;
20610
20611 if (!args) SWIG_fail;
20612 swig_obj[0] = args;
20613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20614 if (!SWIG_IsOK(res1)) {
20615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20616 }
20617 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20626 }
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20634 PyObject *resultobj = 0;
20635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20636 bool result;
20637 void *argp1 = 0 ;
20638 int res1 = 0 ;
20639 PyObject *swig_obj[1] ;
20640
20641 if (!args) SWIG_fail;
20642 swig_obj[0] = args;
20643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20644 if (!SWIG_IsOK(res1)) {
20645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20646 }
20647 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20648 {
20649 PyThreadState* __tstate = wxPyBeginAllowThreads();
20650 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 {
20655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20656 }
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20664 PyObject *resultobj = 0;
20665 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20666 bool result;
20667 void *argp1 = 0 ;
20668 int res1 = 0 ;
20669 PyObject *swig_obj[1] ;
20670
20671 if (!args) SWIG_fail;
20672 swig_obj[0] = args;
20673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20674 if (!SWIG_IsOK(res1)) {
20675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20676 }
20677 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20678 {
20679 PyThreadState* __tstate = wxPyBeginAllowThreads();
20680 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20681 wxPyEndAllowThreads(__tstate);
20682 if (PyErr_Occurred()) SWIG_fail;
20683 }
20684 {
20685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20686 }
20687 return resultobj;
20688 fail:
20689 return NULL;
20690 }
20691
20692
20693 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20694 PyObject *resultobj = 0;
20695 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20696 wxPoint result;
20697 void *argp1 = 0 ;
20698 int res1 = 0 ;
20699 PyObject *swig_obj[1] ;
20700
20701 if (!args) SWIG_fail;
20702 swig_obj[0] = args;
20703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20704 if (!SWIG_IsOK(res1)) {
20705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20706 }
20707 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20708 {
20709 PyThreadState* __tstate = wxPyBeginAllowThreads();
20710 result = (arg1)->GetPosition();
20711 wxPyEndAllowThreads(__tstate);
20712 if (PyErr_Occurred()) SWIG_fail;
20713 }
20714 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20715 return resultobj;
20716 fail:
20717 return NULL;
20718 }
20719
20720
20721 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20722 PyObject *resultobj = 0;
20723 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20724 long *arg2 = (long *) 0 ;
20725 long *arg3 = (long *) 0 ;
20726 void *argp1 = 0 ;
20727 int res1 = 0 ;
20728 long temp2 ;
20729 int res2 = SWIG_TMPOBJ ;
20730 long temp3 ;
20731 int res3 = SWIG_TMPOBJ ;
20732 PyObject *swig_obj[1] ;
20733
20734 arg2 = &temp2;
20735 arg3 = &temp3;
20736 if (!args) SWIG_fail;
20737 swig_obj[0] = args;
20738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20739 if (!SWIG_IsOK(res1)) {
20740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20741 }
20742 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 (arg1)->GetPosition(arg2,arg3);
20746 wxPyEndAllowThreads(__tstate);
20747 if (PyErr_Occurred()) SWIG_fail;
20748 }
20749 resultobj = SWIG_Py_Void();
20750 if (SWIG_IsTmpObj(res2)) {
20751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20752 } else {
20753 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20755 }
20756 if (SWIG_IsTmpObj(res3)) {
20757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20758 } else {
20759 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20761 }
20762 return resultobj;
20763 fail:
20764 return NULL;
20765 }
20766
20767
20768 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20769 PyObject *resultobj = 0;
20770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20771 wxDC *arg2 = 0 ;
20772 wxPoint result;
20773 void *argp1 = 0 ;
20774 int res1 = 0 ;
20775 void *argp2 = 0 ;
20776 int res2 = 0 ;
20777 PyObject * obj0 = 0 ;
20778 PyObject * obj1 = 0 ;
20779 char * kwnames[] = {
20780 (char *) "self",(char *) "dc", NULL
20781 };
20782
20783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20785 if (!SWIG_IsOK(res1)) {
20786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20787 }
20788 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20789 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20790 if (!SWIG_IsOK(res2)) {
20791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20792 }
20793 if (!argp2) {
20794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20795 }
20796 arg2 = reinterpret_cast< wxDC * >(argp2);
20797 {
20798 PyThreadState* __tstate = wxPyBeginAllowThreads();
20799 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20800 wxPyEndAllowThreads(__tstate);
20801 if (PyErr_Occurred()) SWIG_fail;
20802 }
20803 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20804 return resultobj;
20805 fail:
20806 return NULL;
20807 }
20808
20809
20810 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20811 PyObject *resultobj = 0;
20812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20813 int result;
20814 void *argp1 = 0 ;
20815 int res1 = 0 ;
20816 PyObject *swig_obj[1] ;
20817
20818 if (!args) SWIG_fail;
20819 swig_obj[0] = args;
20820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20821 if (!SWIG_IsOK(res1)) {
20822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20823 }
20824 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20825 {
20826 PyThreadState* __tstate = wxPyBeginAllowThreads();
20827 result = (int)((wxMouseEvent const *)arg1)->GetX();
20828 wxPyEndAllowThreads(__tstate);
20829 if (PyErr_Occurred()) SWIG_fail;
20830 }
20831 resultobj = SWIG_From_int(static_cast< int >(result));
20832 return resultobj;
20833 fail:
20834 return NULL;
20835 }
20836
20837
20838 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20839 PyObject *resultobj = 0;
20840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20841 int result;
20842 void *argp1 = 0 ;
20843 int res1 = 0 ;
20844 PyObject *swig_obj[1] ;
20845
20846 if (!args) SWIG_fail;
20847 swig_obj[0] = args;
20848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20849 if (!SWIG_IsOK(res1)) {
20850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20851 }
20852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 result = (int)((wxMouseEvent const *)arg1)->GetY();
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 resultobj = SWIG_From_int(static_cast< int >(result));
20860 return resultobj;
20861 fail:
20862 return NULL;
20863 }
20864
20865
20866 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20867 PyObject *resultobj = 0;
20868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20869 int 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_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20879 }
20880 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 resultobj = SWIG_From_int(static_cast< int >(result));
20888 return resultobj;
20889 fail:
20890 return NULL;
20891 }
20892
20893
20894 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20895 PyObject *resultobj = 0;
20896 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20897 int result;
20898 void *argp1 = 0 ;
20899 int res1 = 0 ;
20900 PyObject *swig_obj[1] ;
20901
20902 if (!args) SWIG_fail;
20903 swig_obj[0] = args;
20904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20905 if (!SWIG_IsOK(res1)) {
20906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20907 }
20908 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20912 wxPyEndAllowThreads(__tstate);
20913 if (PyErr_Occurred()) SWIG_fail;
20914 }
20915 resultobj = SWIG_From_int(static_cast< int >(result));
20916 return resultobj;
20917 fail:
20918 return NULL;
20919 }
20920
20921
20922 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20923 PyObject *resultobj = 0;
20924 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20925 int result;
20926 void *argp1 = 0 ;
20927 int res1 = 0 ;
20928 PyObject *swig_obj[1] ;
20929
20930 if (!args) SWIG_fail;
20931 swig_obj[0] = args;
20932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20933 if (!SWIG_IsOK(res1)) {
20934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20935 }
20936 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20937 {
20938 PyThreadState* __tstate = wxPyBeginAllowThreads();
20939 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20940 wxPyEndAllowThreads(__tstate);
20941 if (PyErr_Occurred()) SWIG_fail;
20942 }
20943 resultobj = SWIG_From_int(static_cast< int >(result));
20944 return resultobj;
20945 fail:
20946 return NULL;
20947 }
20948
20949
20950 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20951 PyObject *resultobj = 0;
20952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20953 bool result;
20954 void *argp1 = 0 ;
20955 int res1 = 0 ;
20956 PyObject *swig_obj[1] ;
20957
20958 if (!args) SWIG_fail;
20959 swig_obj[0] = args;
20960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20961 if (!SWIG_IsOK(res1)) {
20962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20963 }
20964 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 {
20972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20973 }
20974 return resultobj;
20975 fail:
20976 return NULL;
20977 }
20978
20979
20980 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20981 PyObject *resultobj = 0;
20982 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20983 int arg2 ;
20984 void *argp1 = 0 ;
20985 int res1 = 0 ;
20986 int val2 ;
20987 int ecode2 = 0 ;
20988 PyObject *swig_obj[2] ;
20989
20990 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20992 if (!SWIG_IsOK(res1)) {
20993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20994 }
20995 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20996 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20997 if (!SWIG_IsOK(ecode2)) {
20998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20999 }
21000 arg2 = static_cast< int >(val2);
21001 if (arg1) (arg1)->m_x = arg2;
21002
21003 resultobj = SWIG_Py_Void();
21004 return resultobj;
21005 fail:
21006 return NULL;
21007 }
21008
21009
21010 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21011 PyObject *resultobj = 0;
21012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21013 int result;
21014 void *argp1 = 0 ;
21015 int res1 = 0 ;
21016 PyObject *swig_obj[1] ;
21017
21018 if (!args) SWIG_fail;
21019 swig_obj[0] = args;
21020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21021 if (!SWIG_IsOK(res1)) {
21022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21023 }
21024 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21025 result = (int) ((arg1)->m_x);
21026 resultobj = SWIG_From_int(static_cast< int >(result));
21027 return resultobj;
21028 fail:
21029 return NULL;
21030 }
21031
21032
21033 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21034 PyObject *resultobj = 0;
21035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21036 int arg2 ;
21037 void *argp1 = 0 ;
21038 int res1 = 0 ;
21039 int val2 ;
21040 int ecode2 = 0 ;
21041 PyObject *swig_obj[2] ;
21042
21043 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21045 if (!SWIG_IsOK(res1)) {
21046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21047 }
21048 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21049 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21050 if (!SWIG_IsOK(ecode2)) {
21051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21052 }
21053 arg2 = static_cast< int >(val2);
21054 if (arg1) (arg1)->m_y = arg2;
21055
21056 resultobj = SWIG_Py_Void();
21057 return resultobj;
21058 fail:
21059 return NULL;
21060 }
21061
21062
21063 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21064 PyObject *resultobj = 0;
21065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21066 int result;
21067 void *argp1 = 0 ;
21068 int res1 = 0 ;
21069 PyObject *swig_obj[1] ;
21070
21071 if (!args) SWIG_fail;
21072 swig_obj[0] = args;
21073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21074 if (!SWIG_IsOK(res1)) {
21075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21076 }
21077 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21078 result = (int) ((arg1)->m_y);
21079 resultobj = SWIG_From_int(static_cast< int >(result));
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21087 PyObject *resultobj = 0;
21088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21089 bool arg2 ;
21090 void *argp1 = 0 ;
21091 int res1 = 0 ;
21092 bool val2 ;
21093 int ecode2 = 0 ;
21094 PyObject *swig_obj[2] ;
21095
21096 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21098 if (!SWIG_IsOK(res1)) {
21099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21100 }
21101 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21102 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21103 if (!SWIG_IsOK(ecode2)) {
21104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21105 }
21106 arg2 = static_cast< bool >(val2);
21107 if (arg1) (arg1)->m_leftDown = arg2;
21108
21109 resultobj = SWIG_Py_Void();
21110 return resultobj;
21111 fail:
21112 return NULL;
21113 }
21114
21115
21116 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21117 PyObject *resultobj = 0;
21118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21119 bool result;
21120 void *argp1 = 0 ;
21121 int res1 = 0 ;
21122 PyObject *swig_obj[1] ;
21123
21124 if (!args) SWIG_fail;
21125 swig_obj[0] = args;
21126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21127 if (!SWIG_IsOK(res1)) {
21128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21129 }
21130 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21131 result = (bool) ((arg1)->m_leftDown);
21132 {
21133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21134 }
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21142 PyObject *resultobj = 0;
21143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21144 bool arg2 ;
21145 void *argp1 = 0 ;
21146 int res1 = 0 ;
21147 bool val2 ;
21148 int ecode2 = 0 ;
21149 PyObject *swig_obj[2] ;
21150
21151 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21153 if (!SWIG_IsOK(res1)) {
21154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21155 }
21156 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21157 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21158 if (!SWIG_IsOK(ecode2)) {
21159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21160 }
21161 arg2 = static_cast< bool >(val2);
21162 if (arg1) (arg1)->m_middleDown = arg2;
21163
21164 resultobj = SWIG_Py_Void();
21165 return resultobj;
21166 fail:
21167 return NULL;
21168 }
21169
21170
21171 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21172 PyObject *resultobj = 0;
21173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21174 bool result;
21175 void *argp1 = 0 ;
21176 int res1 = 0 ;
21177 PyObject *swig_obj[1] ;
21178
21179 if (!args) SWIG_fail;
21180 swig_obj[0] = args;
21181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21182 if (!SWIG_IsOK(res1)) {
21183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21184 }
21185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21186 result = (bool) ((arg1)->m_middleDown);
21187 {
21188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21189 }
21190 return resultobj;
21191 fail:
21192 return NULL;
21193 }
21194
21195
21196 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21197 PyObject *resultobj = 0;
21198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21199 bool arg2 ;
21200 void *argp1 = 0 ;
21201 int res1 = 0 ;
21202 bool val2 ;
21203 int ecode2 = 0 ;
21204 PyObject *swig_obj[2] ;
21205
21206 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21208 if (!SWIG_IsOK(res1)) {
21209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21210 }
21211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21212 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21213 if (!SWIG_IsOK(ecode2)) {
21214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21215 }
21216 arg2 = static_cast< bool >(val2);
21217 if (arg1) (arg1)->m_rightDown = arg2;
21218
21219 resultobj = SWIG_Py_Void();
21220 return resultobj;
21221 fail:
21222 return NULL;
21223 }
21224
21225
21226 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21227 PyObject *resultobj = 0;
21228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21229 bool result;
21230 void *argp1 = 0 ;
21231 int res1 = 0 ;
21232 PyObject *swig_obj[1] ;
21233
21234 if (!args) SWIG_fail;
21235 swig_obj[0] = args;
21236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21237 if (!SWIG_IsOK(res1)) {
21238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21239 }
21240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21241 result = (bool) ((arg1)->m_rightDown);
21242 {
21243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21244 }
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21252 PyObject *resultobj = 0;
21253 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21254 bool arg2 ;
21255 void *argp1 = 0 ;
21256 int res1 = 0 ;
21257 bool val2 ;
21258 int ecode2 = 0 ;
21259 PyObject *swig_obj[2] ;
21260
21261 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21263 if (!SWIG_IsOK(res1)) {
21264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21265 }
21266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21267 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21268 if (!SWIG_IsOK(ecode2)) {
21269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21270 }
21271 arg2 = static_cast< bool >(val2);
21272 if (arg1) (arg1)->m_controlDown = arg2;
21273
21274 resultobj = SWIG_Py_Void();
21275 return resultobj;
21276 fail:
21277 return NULL;
21278 }
21279
21280
21281 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21282 PyObject *resultobj = 0;
21283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21284 bool result;
21285 void *argp1 = 0 ;
21286 int res1 = 0 ;
21287 PyObject *swig_obj[1] ;
21288
21289 if (!args) SWIG_fail;
21290 swig_obj[0] = args;
21291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21292 if (!SWIG_IsOK(res1)) {
21293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21294 }
21295 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21296 result = (bool) ((arg1)->m_controlDown);
21297 {
21298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21299 }
21300 return resultobj;
21301 fail:
21302 return NULL;
21303 }
21304
21305
21306 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21307 PyObject *resultobj = 0;
21308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21309 bool arg2 ;
21310 void *argp1 = 0 ;
21311 int res1 = 0 ;
21312 bool val2 ;
21313 int ecode2 = 0 ;
21314 PyObject *swig_obj[2] ;
21315
21316 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21318 if (!SWIG_IsOK(res1)) {
21319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21320 }
21321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21322 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21323 if (!SWIG_IsOK(ecode2)) {
21324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21325 }
21326 arg2 = static_cast< bool >(val2);
21327 if (arg1) (arg1)->m_shiftDown = arg2;
21328
21329 resultobj = SWIG_Py_Void();
21330 return resultobj;
21331 fail:
21332 return NULL;
21333 }
21334
21335
21336 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21337 PyObject *resultobj = 0;
21338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21339 bool result;
21340 void *argp1 = 0 ;
21341 int res1 = 0 ;
21342 PyObject *swig_obj[1] ;
21343
21344 if (!args) SWIG_fail;
21345 swig_obj[0] = args;
21346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21347 if (!SWIG_IsOK(res1)) {
21348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21349 }
21350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21351 result = (bool) ((arg1)->m_shiftDown);
21352 {
21353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21354 }
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21362 PyObject *resultobj = 0;
21363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21364 bool arg2 ;
21365 void *argp1 = 0 ;
21366 int res1 = 0 ;
21367 bool val2 ;
21368 int ecode2 = 0 ;
21369 PyObject *swig_obj[2] ;
21370
21371 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21373 if (!SWIG_IsOK(res1)) {
21374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21375 }
21376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21377 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21378 if (!SWIG_IsOK(ecode2)) {
21379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21380 }
21381 arg2 = static_cast< bool >(val2);
21382 if (arg1) (arg1)->m_altDown = arg2;
21383
21384 resultobj = SWIG_Py_Void();
21385 return resultobj;
21386 fail:
21387 return NULL;
21388 }
21389
21390
21391 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21392 PyObject *resultobj = 0;
21393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21394 bool result;
21395 void *argp1 = 0 ;
21396 int res1 = 0 ;
21397 PyObject *swig_obj[1] ;
21398
21399 if (!args) SWIG_fail;
21400 swig_obj[0] = args;
21401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21402 if (!SWIG_IsOK(res1)) {
21403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21404 }
21405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21406 result = (bool) ((arg1)->m_altDown);
21407 {
21408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21409 }
21410 return resultobj;
21411 fail:
21412 return NULL;
21413 }
21414
21415
21416 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21417 PyObject *resultobj = 0;
21418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21419 bool arg2 ;
21420 void *argp1 = 0 ;
21421 int res1 = 0 ;
21422 bool val2 ;
21423 int ecode2 = 0 ;
21424 PyObject *swig_obj[2] ;
21425
21426 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21428 if (!SWIG_IsOK(res1)) {
21429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21430 }
21431 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21432 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21433 if (!SWIG_IsOK(ecode2)) {
21434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21435 }
21436 arg2 = static_cast< bool >(val2);
21437 if (arg1) (arg1)->m_metaDown = arg2;
21438
21439 resultobj = SWIG_Py_Void();
21440 return resultobj;
21441 fail:
21442 return NULL;
21443 }
21444
21445
21446 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21447 PyObject *resultobj = 0;
21448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21449 bool result;
21450 void *argp1 = 0 ;
21451 int res1 = 0 ;
21452 PyObject *swig_obj[1] ;
21453
21454 if (!args) SWIG_fail;
21455 swig_obj[0] = args;
21456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21457 if (!SWIG_IsOK(res1)) {
21458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21459 }
21460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21461 result = (bool) ((arg1)->m_metaDown);
21462 {
21463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21464 }
21465 return resultobj;
21466 fail:
21467 return NULL;
21468 }
21469
21470
21471 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21472 PyObject *resultobj = 0;
21473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21474 int arg2 ;
21475 void *argp1 = 0 ;
21476 int res1 = 0 ;
21477 int val2 ;
21478 int ecode2 = 0 ;
21479 PyObject *swig_obj[2] ;
21480
21481 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21483 if (!SWIG_IsOK(res1)) {
21484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21485 }
21486 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21487 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21488 if (!SWIG_IsOK(ecode2)) {
21489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21490 }
21491 arg2 = static_cast< int >(val2);
21492 if (arg1) (arg1)->m_wheelRotation = arg2;
21493
21494 resultobj = SWIG_Py_Void();
21495 return resultobj;
21496 fail:
21497 return NULL;
21498 }
21499
21500
21501 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21502 PyObject *resultobj = 0;
21503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21504 int result;
21505 void *argp1 = 0 ;
21506 int res1 = 0 ;
21507 PyObject *swig_obj[1] ;
21508
21509 if (!args) SWIG_fail;
21510 swig_obj[0] = args;
21511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21512 if (!SWIG_IsOK(res1)) {
21513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21514 }
21515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21516 result = (int) ((arg1)->m_wheelRotation);
21517 resultobj = SWIG_From_int(static_cast< int >(result));
21518 return resultobj;
21519 fail:
21520 return NULL;
21521 }
21522
21523
21524 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21525 PyObject *resultobj = 0;
21526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21527 int arg2 ;
21528 void *argp1 = 0 ;
21529 int res1 = 0 ;
21530 int val2 ;
21531 int ecode2 = 0 ;
21532 PyObject *swig_obj[2] ;
21533
21534 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21536 if (!SWIG_IsOK(res1)) {
21537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21538 }
21539 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21540 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21541 if (!SWIG_IsOK(ecode2)) {
21542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21543 }
21544 arg2 = static_cast< int >(val2);
21545 if (arg1) (arg1)->m_wheelDelta = arg2;
21546
21547 resultobj = SWIG_Py_Void();
21548 return resultobj;
21549 fail:
21550 return NULL;
21551 }
21552
21553
21554 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21555 PyObject *resultobj = 0;
21556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21557 int result;
21558 void *argp1 = 0 ;
21559 int res1 = 0 ;
21560 PyObject *swig_obj[1] ;
21561
21562 if (!args) SWIG_fail;
21563 swig_obj[0] = args;
21564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21565 if (!SWIG_IsOK(res1)) {
21566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21567 }
21568 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21569 result = (int) ((arg1)->m_wheelDelta);
21570 resultobj = SWIG_From_int(static_cast< int >(result));
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21578 PyObject *resultobj = 0;
21579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21580 int arg2 ;
21581 void *argp1 = 0 ;
21582 int res1 = 0 ;
21583 int val2 ;
21584 int ecode2 = 0 ;
21585 PyObject *swig_obj[2] ;
21586
21587 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21589 if (!SWIG_IsOK(res1)) {
21590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21591 }
21592 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21593 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21594 if (!SWIG_IsOK(ecode2)) {
21595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21596 }
21597 arg2 = static_cast< int >(val2);
21598 if (arg1) (arg1)->m_linesPerAction = arg2;
21599
21600 resultobj = SWIG_Py_Void();
21601 return resultobj;
21602 fail:
21603 return NULL;
21604 }
21605
21606
21607 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21608 PyObject *resultobj = 0;
21609 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21610 int result;
21611 void *argp1 = 0 ;
21612 int res1 = 0 ;
21613 PyObject *swig_obj[1] ;
21614
21615 if (!args) SWIG_fail;
21616 swig_obj[0] = args;
21617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21618 if (!SWIG_IsOK(res1)) {
21619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21620 }
21621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21622 result = (int) ((arg1)->m_linesPerAction);
21623 resultobj = SWIG_From_int(static_cast< int >(result));
21624 return resultobj;
21625 fail:
21626 return NULL;
21627 }
21628
21629
21630 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21631 PyObject *obj;
21632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21633 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21634 return SWIG_Py_Void();
21635 }
21636
21637 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21638 return SWIG_Python_InitShadowInstance(args);
21639 }
21640
21641 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21642 PyObject *resultobj = 0;
21643 int arg1 = (int) 0 ;
21644 int arg2 = (int) 0 ;
21645 wxSetCursorEvent *result = 0 ;
21646 int val1 ;
21647 int ecode1 = 0 ;
21648 int val2 ;
21649 int ecode2 = 0 ;
21650 PyObject * obj0 = 0 ;
21651 PyObject * obj1 = 0 ;
21652 char * kwnames[] = {
21653 (char *) "x",(char *) "y", NULL
21654 };
21655
21656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21657 if (obj0) {
21658 ecode1 = SWIG_AsVal_int(obj0, &val1);
21659 if (!SWIG_IsOK(ecode1)) {
21660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21661 }
21662 arg1 = static_cast< int >(val1);
21663 }
21664 if (obj1) {
21665 ecode2 = SWIG_AsVal_int(obj1, &val2);
21666 if (!SWIG_IsOK(ecode2)) {
21667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21668 }
21669 arg2 = static_cast< int >(val2);
21670 }
21671 {
21672 PyThreadState* __tstate = wxPyBeginAllowThreads();
21673 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21674 wxPyEndAllowThreads(__tstate);
21675 if (PyErr_Occurred()) SWIG_fail;
21676 }
21677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21678 return resultobj;
21679 fail:
21680 return NULL;
21681 }
21682
21683
21684 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21685 PyObject *resultobj = 0;
21686 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21687 int 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_wxSetCursorEvent, 0 | 0 );
21695 if (!SWIG_IsOK(res1)) {
21696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21697 }
21698 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21699 {
21700 PyThreadState* __tstate = wxPyBeginAllowThreads();
21701 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21702 wxPyEndAllowThreads(__tstate);
21703 if (PyErr_Occurred()) SWIG_fail;
21704 }
21705 resultobj = SWIG_From_int(static_cast< int >(result));
21706 return resultobj;
21707 fail:
21708 return NULL;
21709 }
21710
21711
21712 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21713 PyObject *resultobj = 0;
21714 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21715 int result;
21716 void *argp1 = 0 ;
21717 int res1 = 0 ;
21718 PyObject *swig_obj[1] ;
21719
21720 if (!args) SWIG_fail;
21721 swig_obj[0] = args;
21722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21723 if (!SWIG_IsOK(res1)) {
21724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21725 }
21726 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 resultobj = SWIG_From_int(static_cast< int >(result));
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21741 PyObject *resultobj = 0;
21742 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21743 wxCursor *arg2 = 0 ;
21744 void *argp1 = 0 ;
21745 int res1 = 0 ;
21746 void *argp2 = 0 ;
21747 int res2 = 0 ;
21748 PyObject * obj0 = 0 ;
21749 PyObject * obj1 = 0 ;
21750 char * kwnames[] = {
21751 (char *) "self",(char *) "cursor", NULL
21752 };
21753
21754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21756 if (!SWIG_IsOK(res1)) {
21757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21758 }
21759 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21761 if (!SWIG_IsOK(res2)) {
21762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21763 }
21764 if (!argp2) {
21765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21766 }
21767 arg2 = reinterpret_cast< wxCursor * >(argp2);
21768 {
21769 PyThreadState* __tstate = wxPyBeginAllowThreads();
21770 (arg1)->SetCursor((wxCursor const &)*arg2);
21771 wxPyEndAllowThreads(__tstate);
21772 if (PyErr_Occurred()) SWIG_fail;
21773 }
21774 resultobj = SWIG_Py_Void();
21775 return resultobj;
21776 fail:
21777 return NULL;
21778 }
21779
21780
21781 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21782 PyObject *resultobj = 0;
21783 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21784 wxCursor *result = 0 ;
21785 void *argp1 = 0 ;
21786 int res1 = 0 ;
21787 PyObject *swig_obj[1] ;
21788
21789 if (!args) SWIG_fail;
21790 swig_obj[0] = args;
21791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21792 if (!SWIG_IsOK(res1)) {
21793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21794 }
21795 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21796 {
21797 PyThreadState* __tstate = wxPyBeginAllowThreads();
21798 {
21799 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21800 result = (wxCursor *) &_result_ref;
21801 }
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 {
21806 wxCursor* resultptr = new wxCursor(*result);
21807 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21808 }
21809 return resultobj;
21810 fail:
21811 return NULL;
21812 }
21813
21814
21815 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21816 PyObject *resultobj = 0;
21817 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21818 bool result;
21819 void *argp1 = 0 ;
21820 int res1 = 0 ;
21821 PyObject *swig_obj[1] ;
21822
21823 if (!args) SWIG_fail;
21824 swig_obj[0] = args;
21825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21826 if (!SWIG_IsOK(res1)) {
21827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21828 }
21829 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21830 {
21831 PyThreadState* __tstate = wxPyBeginAllowThreads();
21832 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21833 wxPyEndAllowThreads(__tstate);
21834 if (PyErr_Occurred()) SWIG_fail;
21835 }
21836 {
21837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21838 }
21839 return resultobj;
21840 fail:
21841 return NULL;
21842 }
21843
21844
21845 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21846 PyObject *obj;
21847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21848 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21849 return SWIG_Py_Void();
21850 }
21851
21852 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21853 return SWIG_Python_InitShadowInstance(args);
21854 }
21855
21856 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21857 PyObject *resultobj = 0;
21858 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21859 wxKeyEvent *result = 0 ;
21860 int val1 ;
21861 int ecode1 = 0 ;
21862 PyObject * obj0 = 0 ;
21863 char * kwnames[] = {
21864 (char *) "eventType", NULL
21865 };
21866
21867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21868 if (obj0) {
21869 ecode1 = SWIG_AsVal_int(obj0, &val1);
21870 if (!SWIG_IsOK(ecode1)) {
21871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21872 }
21873 arg1 = static_cast< wxEventType >(val1);
21874 }
21875 {
21876 PyThreadState* __tstate = wxPyBeginAllowThreads();
21877 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21878 wxPyEndAllowThreads(__tstate);
21879 if (PyErr_Occurred()) SWIG_fail;
21880 }
21881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21882 return resultobj;
21883 fail:
21884 return NULL;
21885 }
21886
21887
21888 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21889 PyObject *resultobj = 0;
21890 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21891 int result;
21892 void *argp1 = 0 ;
21893 int res1 = 0 ;
21894 PyObject *swig_obj[1] ;
21895
21896 if (!args) SWIG_fail;
21897 swig_obj[0] = args;
21898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21899 if (!SWIG_IsOK(res1)) {
21900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21901 }
21902 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21903 {
21904 PyThreadState* __tstate = wxPyBeginAllowThreads();
21905 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21906 wxPyEndAllowThreads(__tstate);
21907 if (PyErr_Occurred()) SWIG_fail;
21908 }
21909 resultobj = SWIG_From_int(static_cast< int >(result));
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21917 PyObject *resultobj = 0;
21918 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21919 bool result;
21920 void *argp1 = 0 ;
21921 int res1 = 0 ;
21922 PyObject *swig_obj[1] ;
21923
21924 if (!args) SWIG_fail;
21925 swig_obj[0] = args;
21926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21927 if (!SWIG_IsOK(res1)) {
21928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21929 }
21930 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21939 }
21940 return resultobj;
21941 fail:
21942 return NULL;
21943 }
21944
21945
21946 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21947 PyObject *resultobj = 0;
21948 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21949 bool result;
21950 void *argp1 = 0 ;
21951 int res1 = 0 ;
21952 PyObject *swig_obj[1] ;
21953
21954 if (!args) SWIG_fail;
21955 swig_obj[0] = args;
21956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21957 if (!SWIG_IsOK(res1)) {
21958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21959 }
21960 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21961 {
21962 PyThreadState* __tstate = wxPyBeginAllowThreads();
21963 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21964 wxPyEndAllowThreads(__tstate);
21965 if (PyErr_Occurred()) SWIG_fail;
21966 }
21967 {
21968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21969 }
21970 return resultobj;
21971 fail:
21972 return NULL;
21973 }
21974
21975
21976 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21977 PyObject *resultobj = 0;
21978 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21979 bool result;
21980 void *argp1 = 0 ;
21981 int res1 = 0 ;
21982 PyObject *swig_obj[1] ;
21983
21984 if (!args) SWIG_fail;
21985 swig_obj[0] = args;
21986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21987 if (!SWIG_IsOK(res1)) {
21988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21989 }
21990 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21991 {
21992 PyThreadState* __tstate = wxPyBeginAllowThreads();
21993 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21994 wxPyEndAllowThreads(__tstate);
21995 if (PyErr_Occurred()) SWIG_fail;
21996 }
21997 {
21998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21999 }
22000 return resultobj;
22001 fail:
22002 return NULL;
22003 }
22004
22005
22006 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22007 PyObject *resultobj = 0;
22008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22009 bool result;
22010 void *argp1 = 0 ;
22011 int res1 = 0 ;
22012 PyObject *swig_obj[1] ;
22013
22014 if (!args) SWIG_fail;
22015 swig_obj[0] = args;
22016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22017 if (!SWIG_IsOK(res1)) {
22018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22019 }
22020 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22021 {
22022 PyThreadState* __tstate = wxPyBeginAllowThreads();
22023 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22024 wxPyEndAllowThreads(__tstate);
22025 if (PyErr_Occurred()) SWIG_fail;
22026 }
22027 {
22028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22029 }
22030 return resultobj;
22031 fail:
22032 return NULL;
22033 }
22034
22035
22036 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22037 PyObject *resultobj = 0;
22038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22039 bool result;
22040 void *argp1 = 0 ;
22041 int res1 = 0 ;
22042 PyObject *swig_obj[1] ;
22043
22044 if (!args) SWIG_fail;
22045 swig_obj[0] = args;
22046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22047 if (!SWIG_IsOK(res1)) {
22048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22049 }
22050 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22051 {
22052 PyThreadState* __tstate = wxPyBeginAllowThreads();
22053 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22054 wxPyEndAllowThreads(__tstate);
22055 if (PyErr_Occurred()) SWIG_fail;
22056 }
22057 {
22058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22059 }
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22069 bool result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22079 }
22080 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 {
22088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22089 }
22090 return resultobj;
22091 fail:
22092 return NULL;
22093 }
22094
22095
22096 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22097 PyObject *resultobj = 0;
22098 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22099 int result;
22100 void *argp1 = 0 ;
22101 int res1 = 0 ;
22102 PyObject *swig_obj[1] ;
22103
22104 if (!args) SWIG_fail;
22105 swig_obj[0] = args;
22106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22107 if (!SWIG_IsOK(res1)) {
22108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22109 }
22110 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22111 {
22112 PyThreadState* __tstate = wxPyBeginAllowThreads();
22113 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22114 wxPyEndAllowThreads(__tstate);
22115 if (PyErr_Occurred()) SWIG_fail;
22116 }
22117 resultobj = SWIG_From_int(static_cast< int >(result));
22118 return resultobj;
22119 fail:
22120 return NULL;
22121 }
22122
22123
22124 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22125 PyObject *resultobj = 0;
22126 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22127 int result;
22128 void *argp1 = 0 ;
22129 int res1 = 0 ;
22130 PyObject *swig_obj[1] ;
22131
22132 if (!args) SWIG_fail;
22133 swig_obj[0] = args;
22134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22135 if (!SWIG_IsOK(res1)) {
22136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22137 }
22138 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22139 {
22140 PyThreadState* __tstate = wxPyBeginAllowThreads();
22141 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22142 wxPyEndAllowThreads(__tstate);
22143 if (PyErr_Occurred()) SWIG_fail;
22144 }
22145 resultobj = SWIG_From_int(static_cast< int >(result));
22146 return resultobj;
22147 fail:
22148 return NULL;
22149 }
22150
22151
22152 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22153 PyObject *resultobj = 0;
22154 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22155 unsigned int result;
22156 void *argp1 = 0 ;
22157 int res1 = 0 ;
22158 PyObject *swig_obj[1] ;
22159
22160 if (!args) SWIG_fail;
22161 swig_obj[0] = args;
22162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22163 if (!SWIG_IsOK(res1)) {
22164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22165 }
22166 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22170 wxPyEndAllowThreads(__tstate);
22171 if (PyErr_Occurred()) SWIG_fail;
22172 }
22173 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22181 PyObject *resultobj = 0;
22182 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22183 unsigned int result;
22184 void *argp1 = 0 ;
22185 int res1 = 0 ;
22186 PyObject *swig_obj[1] ;
22187
22188 if (!args) SWIG_fail;
22189 swig_obj[0] = args;
22190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22191 if (!SWIG_IsOK(res1)) {
22192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22193 }
22194 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22198 wxPyEndAllowThreads(__tstate);
22199 if (PyErr_Occurred()) SWIG_fail;
22200 }
22201 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22209 PyObject *resultobj = 0;
22210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22211 wxPoint result;
22212 void *argp1 = 0 ;
22213 int res1 = 0 ;
22214 PyObject *swig_obj[1] ;
22215
22216 if (!args) SWIG_fail;
22217 swig_obj[0] = args;
22218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22219 if (!SWIG_IsOK(res1)) {
22220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22221 }
22222 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (arg1)->GetPosition();
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22239 long *arg2 = (long *) 0 ;
22240 long *arg3 = (long *) 0 ;
22241 void *argp1 = 0 ;
22242 int res1 = 0 ;
22243 long temp2 ;
22244 int res2 = SWIG_TMPOBJ ;
22245 long temp3 ;
22246 int res3 = SWIG_TMPOBJ ;
22247 PyObject *swig_obj[1] ;
22248
22249 arg2 = &temp2;
22250 arg3 = &temp3;
22251 if (!args) SWIG_fail;
22252 swig_obj[0] = args;
22253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22254 if (!SWIG_IsOK(res1)) {
22255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22256 }
22257 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22258 {
22259 PyThreadState* __tstate = wxPyBeginAllowThreads();
22260 (arg1)->GetPosition(arg2,arg3);
22261 wxPyEndAllowThreads(__tstate);
22262 if (PyErr_Occurred()) SWIG_fail;
22263 }
22264 resultobj = SWIG_Py_Void();
22265 if (SWIG_IsTmpObj(res2)) {
22266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22267 } else {
22268 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22270 }
22271 if (SWIG_IsTmpObj(res3)) {
22272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22273 } else {
22274 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22276 }
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22284 PyObject *resultobj = 0;
22285 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22286 int result;
22287 void *argp1 = 0 ;
22288 int res1 = 0 ;
22289 PyObject *swig_obj[1] ;
22290
22291 if (!args) SWIG_fail;
22292 swig_obj[0] = args;
22293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22294 if (!SWIG_IsOK(res1)) {
22295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22296 }
22297 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22298 {
22299 PyThreadState* __tstate = wxPyBeginAllowThreads();
22300 result = (int)((wxKeyEvent const *)arg1)->GetX();
22301 wxPyEndAllowThreads(__tstate);
22302 if (PyErr_Occurred()) SWIG_fail;
22303 }
22304 resultobj = SWIG_From_int(static_cast< int >(result));
22305 return resultobj;
22306 fail:
22307 return NULL;
22308 }
22309
22310
22311 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 PyObject *resultobj = 0;
22313 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22314 int result;
22315 void *argp1 = 0 ;
22316 int res1 = 0 ;
22317 PyObject *swig_obj[1] ;
22318
22319 if (!args) SWIG_fail;
22320 swig_obj[0] = args;
22321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22322 if (!SWIG_IsOK(res1)) {
22323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22324 }
22325 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22326 {
22327 PyThreadState* __tstate = wxPyBeginAllowThreads();
22328 result = (int)((wxKeyEvent const *)arg1)->GetY();
22329 wxPyEndAllowThreads(__tstate);
22330 if (PyErr_Occurred()) SWIG_fail;
22331 }
22332 resultobj = SWIG_From_int(static_cast< int >(result));
22333 return resultobj;
22334 fail:
22335 return NULL;
22336 }
22337
22338
22339 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22340 PyObject *resultobj = 0;
22341 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22342 int arg2 ;
22343 void *argp1 = 0 ;
22344 int res1 = 0 ;
22345 int val2 ;
22346 int ecode2 = 0 ;
22347 PyObject *swig_obj[2] ;
22348
22349 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22351 if (!SWIG_IsOK(res1)) {
22352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22353 }
22354 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22355 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22356 if (!SWIG_IsOK(ecode2)) {
22357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22358 }
22359 arg2 = static_cast< int >(val2);
22360 if (arg1) (arg1)->m_x = arg2;
22361
22362 resultobj = SWIG_Py_Void();
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22370 PyObject *resultobj = 0;
22371 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22372 int result;
22373 void *argp1 = 0 ;
22374 int res1 = 0 ;
22375 PyObject *swig_obj[1] ;
22376
22377 if (!args) SWIG_fail;
22378 swig_obj[0] = args;
22379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22380 if (!SWIG_IsOK(res1)) {
22381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22382 }
22383 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22384 result = (int) ((arg1)->m_x);
22385 resultobj = SWIG_From_int(static_cast< int >(result));
22386 return resultobj;
22387 fail:
22388 return NULL;
22389 }
22390
22391
22392 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22393 PyObject *resultobj = 0;
22394 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22395 int arg2 ;
22396 void *argp1 = 0 ;
22397 int res1 = 0 ;
22398 int val2 ;
22399 int ecode2 = 0 ;
22400 PyObject *swig_obj[2] ;
22401
22402 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22404 if (!SWIG_IsOK(res1)) {
22405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22406 }
22407 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22408 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22409 if (!SWIG_IsOK(ecode2)) {
22410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22411 }
22412 arg2 = static_cast< int >(val2);
22413 if (arg1) (arg1)->m_y = arg2;
22414
22415 resultobj = SWIG_Py_Void();
22416 return resultobj;
22417 fail:
22418 return NULL;
22419 }
22420
22421
22422 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22423 PyObject *resultobj = 0;
22424 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22425 int result;
22426 void *argp1 = 0 ;
22427 int res1 = 0 ;
22428 PyObject *swig_obj[1] ;
22429
22430 if (!args) SWIG_fail;
22431 swig_obj[0] = args;
22432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22433 if (!SWIG_IsOK(res1)) {
22434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22435 }
22436 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22437 result = (int) ((arg1)->m_y);
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_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22446 PyObject *resultobj = 0;
22447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22448 long arg2 ;
22449 void *argp1 = 0 ;
22450 int res1 = 0 ;
22451 long val2 ;
22452 int ecode2 = 0 ;
22453 PyObject *swig_obj[2] ;
22454
22455 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22457 if (!SWIG_IsOK(res1)) {
22458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22459 }
22460 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22461 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22462 if (!SWIG_IsOK(ecode2)) {
22463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22464 }
22465 arg2 = static_cast< long >(val2);
22466 if (arg1) (arg1)->m_keyCode = arg2;
22467
22468 resultobj = SWIG_Py_Void();
22469 return resultobj;
22470 fail:
22471 return NULL;
22472 }
22473
22474
22475 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22476 PyObject *resultobj = 0;
22477 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22478 long result;
22479 void *argp1 = 0 ;
22480 int res1 = 0 ;
22481 PyObject *swig_obj[1] ;
22482
22483 if (!args) SWIG_fail;
22484 swig_obj[0] = args;
22485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22486 if (!SWIG_IsOK(res1)) {
22487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22488 }
22489 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22490 result = (long) ((arg1)->m_keyCode);
22491 resultobj = SWIG_From_long(static_cast< long >(result));
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22499 PyObject *resultobj = 0;
22500 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22501 bool arg2 ;
22502 void *argp1 = 0 ;
22503 int res1 = 0 ;
22504 bool val2 ;
22505 int ecode2 = 0 ;
22506 PyObject *swig_obj[2] ;
22507
22508 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22510 if (!SWIG_IsOK(res1)) {
22511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22512 }
22513 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22514 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22515 if (!SWIG_IsOK(ecode2)) {
22516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22517 }
22518 arg2 = static_cast< bool >(val2);
22519 if (arg1) (arg1)->m_controlDown = arg2;
22520
22521 resultobj = SWIG_Py_Void();
22522 return resultobj;
22523 fail:
22524 return NULL;
22525 }
22526
22527
22528 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22529 PyObject *resultobj = 0;
22530 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22531 bool result;
22532 void *argp1 = 0 ;
22533 int res1 = 0 ;
22534 PyObject *swig_obj[1] ;
22535
22536 if (!args) SWIG_fail;
22537 swig_obj[0] = args;
22538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22539 if (!SWIG_IsOK(res1)) {
22540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22541 }
22542 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22543 result = (bool) ((arg1)->m_controlDown);
22544 {
22545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22546 }
22547 return resultobj;
22548 fail:
22549 return NULL;
22550 }
22551
22552
22553 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22554 PyObject *resultobj = 0;
22555 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22556 bool arg2 ;
22557 void *argp1 = 0 ;
22558 int res1 = 0 ;
22559 bool val2 ;
22560 int ecode2 = 0 ;
22561 PyObject *swig_obj[2] ;
22562
22563 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22565 if (!SWIG_IsOK(res1)) {
22566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22567 }
22568 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22569 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22570 if (!SWIG_IsOK(ecode2)) {
22571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22572 }
22573 arg2 = static_cast< bool >(val2);
22574 if (arg1) (arg1)->m_shiftDown = arg2;
22575
22576 resultobj = SWIG_Py_Void();
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22584 PyObject *resultobj = 0;
22585 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22586 bool result;
22587 void *argp1 = 0 ;
22588 int res1 = 0 ;
22589 PyObject *swig_obj[1] ;
22590
22591 if (!args) SWIG_fail;
22592 swig_obj[0] = args;
22593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22594 if (!SWIG_IsOK(res1)) {
22595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22596 }
22597 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22598 result = (bool) ((arg1)->m_shiftDown);
22599 {
22600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22601 }
22602 return resultobj;
22603 fail:
22604 return NULL;
22605 }
22606
22607
22608 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22609 PyObject *resultobj = 0;
22610 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22611 bool arg2 ;
22612 void *argp1 = 0 ;
22613 int res1 = 0 ;
22614 bool val2 ;
22615 int ecode2 = 0 ;
22616 PyObject *swig_obj[2] ;
22617
22618 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22620 if (!SWIG_IsOK(res1)) {
22621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22622 }
22623 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22624 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22625 if (!SWIG_IsOK(ecode2)) {
22626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22627 }
22628 arg2 = static_cast< bool >(val2);
22629 if (arg1) (arg1)->m_altDown = arg2;
22630
22631 resultobj = SWIG_Py_Void();
22632 return resultobj;
22633 fail:
22634 return NULL;
22635 }
22636
22637
22638 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22639 PyObject *resultobj = 0;
22640 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22641 bool result;
22642 void *argp1 = 0 ;
22643 int res1 = 0 ;
22644 PyObject *swig_obj[1] ;
22645
22646 if (!args) SWIG_fail;
22647 swig_obj[0] = args;
22648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22649 if (!SWIG_IsOK(res1)) {
22650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22651 }
22652 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22653 result = (bool) ((arg1)->m_altDown);
22654 {
22655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22656 }
22657 return resultobj;
22658 fail:
22659 return NULL;
22660 }
22661
22662
22663 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22664 PyObject *resultobj = 0;
22665 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22666 bool arg2 ;
22667 void *argp1 = 0 ;
22668 int res1 = 0 ;
22669 bool val2 ;
22670 int ecode2 = 0 ;
22671 PyObject *swig_obj[2] ;
22672
22673 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22675 if (!SWIG_IsOK(res1)) {
22676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22677 }
22678 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22679 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22680 if (!SWIG_IsOK(ecode2)) {
22681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22682 }
22683 arg2 = static_cast< bool >(val2);
22684 if (arg1) (arg1)->m_metaDown = arg2;
22685
22686 resultobj = SWIG_Py_Void();
22687 return resultobj;
22688 fail:
22689 return NULL;
22690 }
22691
22692
22693 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22694 PyObject *resultobj = 0;
22695 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22696 bool result;
22697 void *argp1 = 0 ;
22698 int res1 = 0 ;
22699 PyObject *swig_obj[1] ;
22700
22701 if (!args) SWIG_fail;
22702 swig_obj[0] = args;
22703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22704 if (!SWIG_IsOK(res1)) {
22705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22706 }
22707 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22708 result = (bool) ((arg1)->m_metaDown);
22709 {
22710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22711 }
22712 return resultobj;
22713 fail:
22714 return NULL;
22715 }
22716
22717
22718 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22719 PyObject *resultobj = 0;
22720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22721 bool arg2 ;
22722 void *argp1 = 0 ;
22723 int res1 = 0 ;
22724 bool val2 ;
22725 int ecode2 = 0 ;
22726 PyObject *swig_obj[2] ;
22727
22728 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22730 if (!SWIG_IsOK(res1)) {
22731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22732 }
22733 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22734 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22735 if (!SWIG_IsOK(ecode2)) {
22736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22737 }
22738 arg2 = static_cast< bool >(val2);
22739 if (arg1) (arg1)->m_scanCode = arg2;
22740
22741 resultobj = SWIG_Py_Void();
22742 return resultobj;
22743 fail:
22744 return NULL;
22745 }
22746
22747
22748 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22749 PyObject *resultobj = 0;
22750 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22751 bool result;
22752 void *argp1 = 0 ;
22753 int res1 = 0 ;
22754 PyObject *swig_obj[1] ;
22755
22756 if (!args) SWIG_fail;
22757 swig_obj[0] = args;
22758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22759 if (!SWIG_IsOK(res1)) {
22760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22761 }
22762 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22763 result = (bool) ((arg1)->m_scanCode);
22764 {
22765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22766 }
22767 return resultobj;
22768 fail:
22769 return NULL;
22770 }
22771
22772
22773 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22774 PyObject *resultobj = 0;
22775 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22776 unsigned int arg2 ;
22777 void *argp1 = 0 ;
22778 int res1 = 0 ;
22779 unsigned int val2 ;
22780 int ecode2 = 0 ;
22781 PyObject *swig_obj[2] ;
22782
22783 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22785 if (!SWIG_IsOK(res1)) {
22786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22787 }
22788 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22789 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22790 if (!SWIG_IsOK(ecode2)) {
22791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22792 }
22793 arg2 = static_cast< unsigned int >(val2);
22794 if (arg1) (arg1)->m_rawCode = arg2;
22795
22796 resultobj = SWIG_Py_Void();
22797 return resultobj;
22798 fail:
22799 return NULL;
22800 }
22801
22802
22803 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22804 PyObject *resultobj = 0;
22805 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22806 unsigned int result;
22807 void *argp1 = 0 ;
22808 int res1 = 0 ;
22809 PyObject *swig_obj[1] ;
22810
22811 if (!args) SWIG_fail;
22812 swig_obj[0] = args;
22813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22814 if (!SWIG_IsOK(res1)) {
22815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22816 }
22817 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22818 result = (unsigned int) ((arg1)->m_rawCode);
22819 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22820 return resultobj;
22821 fail:
22822 return NULL;
22823 }
22824
22825
22826 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22827 PyObject *resultobj = 0;
22828 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22829 unsigned int arg2 ;
22830 void *argp1 = 0 ;
22831 int res1 = 0 ;
22832 unsigned int val2 ;
22833 int ecode2 = 0 ;
22834 PyObject *swig_obj[2] ;
22835
22836 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22838 if (!SWIG_IsOK(res1)) {
22839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22840 }
22841 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22842 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22843 if (!SWIG_IsOK(ecode2)) {
22844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22845 }
22846 arg2 = static_cast< unsigned int >(val2);
22847 if (arg1) (arg1)->m_rawFlags = arg2;
22848
22849 resultobj = SWIG_Py_Void();
22850 return resultobj;
22851 fail:
22852 return NULL;
22853 }
22854
22855
22856 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22857 PyObject *resultobj = 0;
22858 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22859 unsigned int result;
22860 void *argp1 = 0 ;
22861 int res1 = 0 ;
22862 PyObject *swig_obj[1] ;
22863
22864 if (!args) SWIG_fail;
22865 swig_obj[0] = args;
22866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22867 if (!SWIG_IsOK(res1)) {
22868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22869 }
22870 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22871 result = (unsigned int) ((arg1)->m_rawFlags);
22872 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22873 return resultobj;
22874 fail:
22875 return NULL;
22876 }
22877
22878
22879 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22880 PyObject *obj;
22881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22882 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22883 return SWIG_Py_Void();
22884 }
22885
22886 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22887 return SWIG_Python_InitShadowInstance(args);
22888 }
22889
22890 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22891 PyObject *resultobj = 0;
22892 wxSize const &arg1_defvalue = wxDefaultSize ;
22893 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22894 int arg2 = (int) 0 ;
22895 wxSizeEvent *result = 0 ;
22896 wxSize temp1 ;
22897 int val2 ;
22898 int ecode2 = 0 ;
22899 PyObject * obj0 = 0 ;
22900 PyObject * obj1 = 0 ;
22901 char * kwnames[] = {
22902 (char *) "sz",(char *) "winid", NULL
22903 };
22904
22905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22906 if (obj0) {
22907 {
22908 arg1 = &temp1;
22909 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22910 }
22911 }
22912 if (obj1) {
22913 ecode2 = SWIG_AsVal_int(obj1, &val2);
22914 if (!SWIG_IsOK(ecode2)) {
22915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22916 }
22917 arg2 = static_cast< int >(val2);
22918 }
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22922 wxPyEndAllowThreads(__tstate);
22923 if (PyErr_Occurred()) SWIG_fail;
22924 }
22925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22926 return resultobj;
22927 fail:
22928 return NULL;
22929 }
22930
22931
22932 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22933 PyObject *resultobj = 0;
22934 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22935 wxSize result;
22936 void *argp1 = 0 ;
22937 int res1 = 0 ;
22938 PyObject *swig_obj[1] ;
22939
22940 if (!args) SWIG_fail;
22941 swig_obj[0] = args;
22942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22943 if (!SWIG_IsOK(res1)) {
22944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22945 }
22946 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22947 {
22948 PyThreadState* __tstate = wxPyBeginAllowThreads();
22949 result = ((wxSizeEvent const *)arg1)->GetSize();
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22961 PyObject *resultobj = 0;
22962 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22963 wxRect result;
22964 void *argp1 = 0 ;
22965 int res1 = 0 ;
22966 PyObject *swig_obj[1] ;
22967
22968 if (!args) SWIG_fail;
22969 swig_obj[0] = args;
22970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22971 if (!SWIG_IsOK(res1)) {
22972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22973 }
22974 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 result = ((wxSizeEvent const *)arg1)->GetRect();
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22989 PyObject *resultobj = 0;
22990 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22991 wxRect arg2 ;
22992 void *argp1 = 0 ;
22993 int res1 = 0 ;
22994 void *argp2 ;
22995 int res2 = 0 ;
22996 PyObject * obj0 = 0 ;
22997 PyObject * obj1 = 0 ;
22998 char * kwnames[] = {
22999 (char *) "self",(char *) "rect", NULL
23000 };
23001
23002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23004 if (!SWIG_IsOK(res1)) {
23005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23006 }
23007 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23008 {
23009 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23010 if (!SWIG_IsOK(res2)) {
23011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23012 }
23013 if (!argp2) {
23014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23015 } else {
23016 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23017 arg2 = *temp;
23018 if (SWIG_IsNewObj(res2)) delete temp;
23019 }
23020 }
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 (arg1)->SetRect(arg2);
23024 wxPyEndAllowThreads(__tstate);
23025 if (PyErr_Occurred()) SWIG_fail;
23026 }
23027 resultobj = SWIG_Py_Void();
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23035 PyObject *resultobj = 0;
23036 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23037 wxSize arg2 ;
23038 void *argp1 = 0 ;
23039 int res1 = 0 ;
23040 void *argp2 ;
23041 int res2 = 0 ;
23042 PyObject * obj0 = 0 ;
23043 PyObject * obj1 = 0 ;
23044 char * kwnames[] = {
23045 (char *) "self",(char *) "size", NULL
23046 };
23047
23048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23050 if (!SWIG_IsOK(res1)) {
23051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23052 }
23053 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23054 {
23055 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23056 if (!SWIG_IsOK(res2)) {
23057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23058 }
23059 if (!argp2) {
23060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23061 } else {
23062 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23063 arg2 = *temp;
23064 if (SWIG_IsNewObj(res2)) delete temp;
23065 }
23066 }
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 wxSizeEvent_SetSize(arg1,arg2);
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 resultobj = SWIG_Py_Void();
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081 PyObject *resultobj = 0;
23082 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23083 wxSize *arg2 = (wxSize *) 0 ;
23084 void *argp1 = 0 ;
23085 int res1 = 0 ;
23086 void *argp2 = 0 ;
23087 int res2 = 0 ;
23088 PyObject *swig_obj[2] ;
23089
23090 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23094 }
23095 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23096 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23097 if (!SWIG_IsOK(res2)) {
23098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23099 }
23100 arg2 = reinterpret_cast< wxSize * >(argp2);
23101 if (arg1) (arg1)->m_size = *arg2;
23102
23103 resultobj = SWIG_Py_Void();
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23111 PyObject *resultobj = 0;
23112 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23113 wxSize *result = 0 ;
23114 void *argp1 = 0 ;
23115 int res1 = 0 ;
23116 PyObject *swig_obj[1] ;
23117
23118 if (!args) SWIG_fail;
23119 swig_obj[0] = args;
23120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23121 if (!SWIG_IsOK(res1)) {
23122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23123 }
23124 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23125 result = (wxSize *)& ((arg1)->m_size);
23126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23127 return resultobj;
23128 fail:
23129 return NULL;
23130 }
23131
23132
23133 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23134 PyObject *resultobj = 0;
23135 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23136 wxRect *arg2 = (wxRect *) 0 ;
23137 void *argp1 = 0 ;
23138 int res1 = 0 ;
23139 void *argp2 = 0 ;
23140 int res2 = 0 ;
23141 PyObject *swig_obj[2] ;
23142
23143 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23145 if (!SWIG_IsOK(res1)) {
23146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23147 }
23148 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23149 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23150 if (!SWIG_IsOK(res2)) {
23151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23152 }
23153 arg2 = reinterpret_cast< wxRect * >(argp2);
23154 if (arg1) (arg1)->m_rect = *arg2;
23155
23156 resultobj = SWIG_Py_Void();
23157 return resultobj;
23158 fail:
23159 return NULL;
23160 }
23161
23162
23163 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23164 PyObject *resultobj = 0;
23165 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23166 wxRect *result = 0 ;
23167 void *argp1 = 0 ;
23168 int res1 = 0 ;
23169 PyObject *swig_obj[1] ;
23170
23171 if (!args) SWIG_fail;
23172 swig_obj[0] = args;
23173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23174 if (!SWIG_IsOK(res1)) {
23175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23176 }
23177 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23178 result = (wxRect *)& ((arg1)->m_rect);
23179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23180 return resultobj;
23181 fail:
23182 return NULL;
23183 }
23184
23185
23186 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23187 PyObject *obj;
23188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23189 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23190 return SWIG_Py_Void();
23191 }
23192
23193 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23194 return SWIG_Python_InitShadowInstance(args);
23195 }
23196
23197 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23198 PyObject *resultobj = 0;
23199 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23200 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23201 int arg2 = (int) 0 ;
23202 wxMoveEvent *result = 0 ;
23203 wxPoint temp1 ;
23204 int val2 ;
23205 int ecode2 = 0 ;
23206 PyObject * obj0 = 0 ;
23207 PyObject * obj1 = 0 ;
23208 char * kwnames[] = {
23209 (char *) "pos",(char *) "winid", NULL
23210 };
23211
23212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23213 if (obj0) {
23214 {
23215 arg1 = &temp1;
23216 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23217 }
23218 }
23219 if (obj1) {
23220 ecode2 = SWIG_AsVal_int(obj1, &val2);
23221 if (!SWIG_IsOK(ecode2)) {
23222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23223 }
23224 arg2 = static_cast< int >(val2);
23225 }
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23229 wxPyEndAllowThreads(__tstate);
23230 if (PyErr_Occurred()) SWIG_fail;
23231 }
23232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23233 return resultobj;
23234 fail:
23235 return NULL;
23236 }
23237
23238
23239 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23240 PyObject *resultobj = 0;
23241 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23242 wxPoint result;
23243 void *argp1 = 0 ;
23244 int res1 = 0 ;
23245 PyObject *swig_obj[1] ;
23246
23247 if (!args) SWIG_fail;
23248 swig_obj[0] = args;
23249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23250 if (!SWIG_IsOK(res1)) {
23251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23252 }
23253 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23254 {
23255 PyThreadState* __tstate = wxPyBeginAllowThreads();
23256 result = ((wxMoveEvent const *)arg1)->GetPosition();
23257 wxPyEndAllowThreads(__tstate);
23258 if (PyErr_Occurred()) SWIG_fail;
23259 }
23260 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23268 PyObject *resultobj = 0;
23269 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23270 wxRect result;
23271 void *argp1 = 0 ;
23272 int res1 = 0 ;
23273 PyObject *swig_obj[1] ;
23274
23275 if (!args) SWIG_fail;
23276 swig_obj[0] = args;
23277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23278 if (!SWIG_IsOK(res1)) {
23279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23280 }
23281 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 result = ((wxMoveEvent const *)arg1)->GetRect();
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23289 return resultobj;
23290 fail:
23291 return NULL;
23292 }
23293
23294
23295 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23296 PyObject *resultobj = 0;
23297 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23298 wxRect *arg2 = 0 ;
23299 void *argp1 = 0 ;
23300 int res1 = 0 ;
23301 wxRect temp2 ;
23302 PyObject * obj0 = 0 ;
23303 PyObject * obj1 = 0 ;
23304 char * kwnames[] = {
23305 (char *) "self",(char *) "rect", NULL
23306 };
23307
23308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23310 if (!SWIG_IsOK(res1)) {
23311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23312 }
23313 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23314 {
23315 arg2 = &temp2;
23316 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23317 }
23318 {
23319 PyThreadState* __tstate = wxPyBeginAllowThreads();
23320 (arg1)->SetRect((wxRect const &)*arg2);
23321 wxPyEndAllowThreads(__tstate);
23322 if (PyErr_Occurred()) SWIG_fail;
23323 }
23324 resultobj = SWIG_Py_Void();
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj = 0;
23333 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23334 wxPoint *arg2 = 0 ;
23335 void *argp1 = 0 ;
23336 int res1 = 0 ;
23337 wxPoint temp2 ;
23338 PyObject * obj0 = 0 ;
23339 PyObject * obj1 = 0 ;
23340 char * kwnames[] = {
23341 (char *) "self",(char *) "pos", NULL
23342 };
23343
23344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23346 if (!SWIG_IsOK(res1)) {
23347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23348 }
23349 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23350 {
23351 arg2 = &temp2;
23352 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23353 }
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 (arg1)->SetPosition((wxPoint const &)*arg2);
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 resultobj = SWIG_Py_Void();
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23368 PyObject *obj;
23369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23370 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23371 return SWIG_Py_Void();
23372 }
23373
23374 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23375 return SWIG_Python_InitShadowInstance(args);
23376 }
23377
23378 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23379 PyObject *resultobj = 0;
23380 int arg1 = (int) 0 ;
23381 wxPaintEvent *result = 0 ;
23382 int val1 ;
23383 int ecode1 = 0 ;
23384 PyObject * obj0 = 0 ;
23385 char * kwnames[] = {
23386 (char *) "Id", NULL
23387 };
23388
23389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23390 if (obj0) {
23391 ecode1 = SWIG_AsVal_int(obj0, &val1);
23392 if (!SWIG_IsOK(ecode1)) {
23393 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23394 }
23395 arg1 = static_cast< int >(val1);
23396 }
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23400 wxPyEndAllowThreads(__tstate);
23401 if (PyErr_Occurred()) SWIG_fail;
23402 }
23403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23404 return resultobj;
23405 fail:
23406 return NULL;
23407 }
23408
23409
23410 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23411 PyObject *obj;
23412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23413 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23414 return SWIG_Py_Void();
23415 }
23416
23417 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23418 return SWIG_Python_InitShadowInstance(args);
23419 }
23420
23421 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23422 PyObject *resultobj = 0;
23423 int arg1 = (int) 0 ;
23424 wxNcPaintEvent *result = 0 ;
23425 int val1 ;
23426 int ecode1 = 0 ;
23427 PyObject * obj0 = 0 ;
23428 char * kwnames[] = {
23429 (char *) "winid", NULL
23430 };
23431
23432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23433 if (obj0) {
23434 ecode1 = SWIG_AsVal_int(obj0, &val1);
23435 if (!SWIG_IsOK(ecode1)) {
23436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23437 }
23438 arg1 = static_cast< int >(val1);
23439 }
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23443 wxPyEndAllowThreads(__tstate);
23444 if (PyErr_Occurred()) SWIG_fail;
23445 }
23446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23447 return resultobj;
23448 fail:
23449 return NULL;
23450 }
23451
23452
23453 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23454 PyObject *obj;
23455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23456 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23457 return SWIG_Py_Void();
23458 }
23459
23460 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23461 return SWIG_Python_InitShadowInstance(args);
23462 }
23463
23464 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23465 PyObject *resultobj = 0;
23466 int arg1 = (int) 0 ;
23467 wxDC *arg2 = (wxDC *) NULL ;
23468 wxEraseEvent *result = 0 ;
23469 int val1 ;
23470 int ecode1 = 0 ;
23471 void *argp2 = 0 ;
23472 int res2 = 0 ;
23473 PyObject * obj0 = 0 ;
23474 PyObject * obj1 = 0 ;
23475 char * kwnames[] = {
23476 (char *) "Id",(char *) "dc", NULL
23477 };
23478
23479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23480 if (obj0) {
23481 ecode1 = SWIG_AsVal_int(obj0, &val1);
23482 if (!SWIG_IsOK(ecode1)) {
23483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23484 }
23485 arg1 = static_cast< int >(val1);
23486 }
23487 if (obj1) {
23488 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23489 if (!SWIG_IsOK(res2)) {
23490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23491 }
23492 arg2 = reinterpret_cast< wxDC * >(argp2);
23493 }
23494 {
23495 PyThreadState* __tstate = wxPyBeginAllowThreads();
23496 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23497 wxPyEndAllowThreads(__tstate);
23498 if (PyErr_Occurred()) SWIG_fail;
23499 }
23500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23501 return resultobj;
23502 fail:
23503 return NULL;
23504 }
23505
23506
23507 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23508 PyObject *resultobj = 0;
23509 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23510 wxDC *result = 0 ;
23511 void *argp1 = 0 ;
23512 int res1 = 0 ;
23513 PyObject *swig_obj[1] ;
23514
23515 if (!args) SWIG_fail;
23516 swig_obj[0] = args;
23517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23518 if (!SWIG_IsOK(res1)) {
23519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23520 }
23521 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23522 {
23523 PyThreadState* __tstate = wxPyBeginAllowThreads();
23524 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23525 wxPyEndAllowThreads(__tstate);
23526 if (PyErr_Occurred()) SWIG_fail;
23527 }
23528 {
23529 resultobj = wxPyMake_wxObject(result, (bool)0);
23530 }
23531 return resultobj;
23532 fail:
23533 return NULL;
23534 }
23535
23536
23537 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23538 PyObject *obj;
23539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23540 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23541 return SWIG_Py_Void();
23542 }
23543
23544 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23545 return SWIG_Python_InitShadowInstance(args);
23546 }
23547
23548 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj = 0;
23550 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23551 int arg2 = (int) 0 ;
23552 wxFocusEvent *result = 0 ;
23553 int val1 ;
23554 int ecode1 = 0 ;
23555 int val2 ;
23556 int ecode2 = 0 ;
23557 PyObject * obj0 = 0 ;
23558 PyObject * obj1 = 0 ;
23559 char * kwnames[] = {
23560 (char *) "type",(char *) "winid", NULL
23561 };
23562
23563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23564 if (obj0) {
23565 ecode1 = SWIG_AsVal_int(obj0, &val1);
23566 if (!SWIG_IsOK(ecode1)) {
23567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23568 }
23569 arg1 = static_cast< wxEventType >(val1);
23570 }
23571 if (obj1) {
23572 ecode2 = SWIG_AsVal_int(obj1, &val2);
23573 if (!SWIG_IsOK(ecode2)) {
23574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23575 }
23576 arg2 = static_cast< int >(val2);
23577 }
23578 {
23579 PyThreadState* __tstate = wxPyBeginAllowThreads();
23580 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23594 wxWindow *result = 0 ;
23595 void *argp1 = 0 ;
23596 int res1 = 0 ;
23597 PyObject *swig_obj[1] ;
23598
23599 if (!args) SWIG_fail;
23600 swig_obj[0] = args;
23601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23602 if (!SWIG_IsOK(res1)) {
23603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23604 }
23605 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 resultobj = wxPyMake_wxObject(result, (bool)0);
23614 }
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23622 PyObject *resultobj = 0;
23623 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23624 wxWindow *arg2 = (wxWindow *) 0 ;
23625 void *argp1 = 0 ;
23626 int res1 = 0 ;
23627 void *argp2 = 0 ;
23628 int res2 = 0 ;
23629 PyObject * obj0 = 0 ;
23630 PyObject * obj1 = 0 ;
23631 char * kwnames[] = {
23632 (char *) "self",(char *) "win", NULL
23633 };
23634
23635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23637 if (!SWIG_IsOK(res1)) {
23638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23639 }
23640 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23642 if (!SWIG_IsOK(res2)) {
23643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23644 }
23645 arg2 = reinterpret_cast< wxWindow * >(argp2);
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 (arg1)->SetWindow(arg2);
23649 wxPyEndAllowThreads(__tstate);
23650 if (PyErr_Occurred()) SWIG_fail;
23651 }
23652 resultobj = SWIG_Py_Void();
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23660 PyObject *obj;
23661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23662 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23663 return SWIG_Py_Void();
23664 }
23665
23666 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23667 return SWIG_Python_InitShadowInstance(args);
23668 }
23669
23670 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23671 PyObject *resultobj = 0;
23672 wxWindow *arg1 = (wxWindow *) NULL ;
23673 wxChildFocusEvent *result = 0 ;
23674 void *argp1 = 0 ;
23675 int res1 = 0 ;
23676 PyObject * obj0 = 0 ;
23677 char * kwnames[] = {
23678 (char *) "win", NULL
23679 };
23680
23681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23682 if (obj0) {
23683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23684 if (!SWIG_IsOK(res1)) {
23685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23686 }
23687 arg1 = reinterpret_cast< wxWindow * >(argp1);
23688 }
23689 {
23690 PyThreadState* __tstate = wxPyBeginAllowThreads();
23691 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23696 return resultobj;
23697 fail:
23698 return NULL;
23699 }
23700
23701
23702 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23703 PyObject *resultobj = 0;
23704 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23705 wxWindow *result = 0 ;
23706 void *argp1 = 0 ;
23707 int res1 = 0 ;
23708 PyObject *swig_obj[1] ;
23709
23710 if (!args) SWIG_fail;
23711 swig_obj[0] = args;
23712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23713 if (!SWIG_IsOK(res1)) {
23714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23715 }
23716 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23720 wxPyEndAllowThreads(__tstate);
23721 if (PyErr_Occurred()) SWIG_fail;
23722 }
23723 {
23724 resultobj = wxPyMake_wxObject(result, (bool)0);
23725 }
23726 return resultobj;
23727 fail:
23728 return NULL;
23729 }
23730
23731
23732 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23733 PyObject *obj;
23734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23735 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23736 return SWIG_Py_Void();
23737 }
23738
23739 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23740 return SWIG_Python_InitShadowInstance(args);
23741 }
23742
23743 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23744 PyObject *resultobj = 0;
23745 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23746 bool arg2 = (bool) true ;
23747 int arg3 = (int) 0 ;
23748 wxActivateEvent *result = 0 ;
23749 int val1 ;
23750 int ecode1 = 0 ;
23751 bool val2 ;
23752 int ecode2 = 0 ;
23753 int val3 ;
23754 int ecode3 = 0 ;
23755 PyObject * obj0 = 0 ;
23756 PyObject * obj1 = 0 ;
23757 PyObject * obj2 = 0 ;
23758 char * kwnames[] = {
23759 (char *) "type",(char *) "active",(char *) "Id", NULL
23760 };
23761
23762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23763 if (obj0) {
23764 ecode1 = SWIG_AsVal_int(obj0, &val1);
23765 if (!SWIG_IsOK(ecode1)) {
23766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23767 }
23768 arg1 = static_cast< wxEventType >(val1);
23769 }
23770 if (obj1) {
23771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23772 if (!SWIG_IsOK(ecode2)) {
23773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23774 }
23775 arg2 = static_cast< bool >(val2);
23776 }
23777 if (obj2) {
23778 ecode3 = SWIG_AsVal_int(obj2, &val3);
23779 if (!SWIG_IsOK(ecode3)) {
23780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23781 }
23782 arg3 = static_cast< int >(val3);
23783 }
23784 {
23785 PyThreadState* __tstate = wxPyBeginAllowThreads();
23786 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23798 PyObject *resultobj = 0;
23799 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23800 bool result;
23801 void *argp1 = 0 ;
23802 int res1 = 0 ;
23803 PyObject *swig_obj[1] ;
23804
23805 if (!args) SWIG_fail;
23806 swig_obj[0] = args;
23807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23808 if (!SWIG_IsOK(res1)) {
23809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23810 }
23811 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23812 {
23813 PyThreadState* __tstate = wxPyBeginAllowThreads();
23814 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23815 wxPyEndAllowThreads(__tstate);
23816 if (PyErr_Occurred()) SWIG_fail;
23817 }
23818 {
23819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23820 }
23821 return resultobj;
23822 fail:
23823 return NULL;
23824 }
23825
23826
23827 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23828 PyObject *obj;
23829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23830 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23831 return SWIG_Py_Void();
23832 }
23833
23834 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23835 return SWIG_Python_InitShadowInstance(args);
23836 }
23837
23838 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23839 PyObject *resultobj = 0;
23840 int arg1 = (int) 0 ;
23841 wxInitDialogEvent *result = 0 ;
23842 int val1 ;
23843 int ecode1 = 0 ;
23844 PyObject * obj0 = 0 ;
23845 char * kwnames[] = {
23846 (char *) "Id", NULL
23847 };
23848
23849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23850 if (obj0) {
23851 ecode1 = SWIG_AsVal_int(obj0, &val1);
23852 if (!SWIG_IsOK(ecode1)) {
23853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23854 }
23855 arg1 = static_cast< int >(val1);
23856 }
23857 {
23858 PyThreadState* __tstate = wxPyBeginAllowThreads();
23859 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23860 wxPyEndAllowThreads(__tstate);
23861 if (PyErr_Occurred()) SWIG_fail;
23862 }
23863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23864 return resultobj;
23865 fail:
23866 return NULL;
23867 }
23868
23869
23870 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23871 PyObject *obj;
23872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23873 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23874 return SWIG_Py_Void();
23875 }
23876
23877 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23878 return SWIG_Python_InitShadowInstance(args);
23879 }
23880
23881 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23882 PyObject *resultobj = 0;
23883 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23884 int arg2 = (int) 0 ;
23885 wxMenu *arg3 = (wxMenu *) NULL ;
23886 wxMenuEvent *result = 0 ;
23887 int val1 ;
23888 int ecode1 = 0 ;
23889 int val2 ;
23890 int ecode2 = 0 ;
23891 void *argp3 = 0 ;
23892 int res3 = 0 ;
23893 PyObject * obj0 = 0 ;
23894 PyObject * obj1 = 0 ;
23895 PyObject * obj2 = 0 ;
23896 char * kwnames[] = {
23897 (char *) "type",(char *) "winid",(char *) "menu", NULL
23898 };
23899
23900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23901 if (obj0) {
23902 ecode1 = SWIG_AsVal_int(obj0, &val1);
23903 if (!SWIG_IsOK(ecode1)) {
23904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23905 }
23906 arg1 = static_cast< wxEventType >(val1);
23907 }
23908 if (obj1) {
23909 ecode2 = SWIG_AsVal_int(obj1, &val2);
23910 if (!SWIG_IsOK(ecode2)) {
23911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23912 }
23913 arg2 = static_cast< int >(val2);
23914 }
23915 if (obj2) {
23916 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23917 if (!SWIG_IsOK(res3)) {
23918 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23919 }
23920 arg3 = reinterpret_cast< wxMenu * >(argp3);
23921 }
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23936 PyObject *resultobj = 0;
23937 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23938 int result;
23939 void *argp1 = 0 ;
23940 int res1 = 0 ;
23941 PyObject *swig_obj[1] ;
23942
23943 if (!args) SWIG_fail;
23944 swig_obj[0] = args;
23945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23946 if (!SWIG_IsOK(res1)) {
23947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23948 }
23949 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23950 {
23951 PyThreadState* __tstate = wxPyBeginAllowThreads();
23952 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23953 wxPyEndAllowThreads(__tstate);
23954 if (PyErr_Occurred()) SWIG_fail;
23955 }
23956 resultobj = SWIG_From_int(static_cast< int >(result));
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23964 PyObject *resultobj = 0;
23965 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23966 bool result;
23967 void *argp1 = 0 ;
23968 int res1 = 0 ;
23969 PyObject *swig_obj[1] ;
23970
23971 if (!args) SWIG_fail;
23972 swig_obj[0] = args;
23973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23974 if (!SWIG_IsOK(res1)) {
23975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23976 }
23977 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23978 {
23979 PyThreadState* __tstate = wxPyBeginAllowThreads();
23980 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23981 wxPyEndAllowThreads(__tstate);
23982 if (PyErr_Occurred()) SWIG_fail;
23983 }
23984 {
23985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23986 }
23987 return resultobj;
23988 fail:
23989 return NULL;
23990 }
23991
23992
23993 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23994 PyObject *resultobj = 0;
23995 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23996 wxMenu *result = 0 ;
23997 void *argp1 = 0 ;
23998 int res1 = 0 ;
23999 PyObject *swig_obj[1] ;
24000
24001 if (!args) SWIG_fail;
24002 swig_obj[0] = args;
24003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24004 if (!SWIG_IsOK(res1)) {
24005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24006 }
24007 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24008 {
24009 PyThreadState* __tstate = wxPyBeginAllowThreads();
24010 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24011 wxPyEndAllowThreads(__tstate);
24012 if (PyErr_Occurred()) SWIG_fail;
24013 }
24014 {
24015 resultobj = wxPyMake_wxObject(result, (bool)0);
24016 }
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24024 PyObject *obj;
24025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24026 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24027 return SWIG_Py_Void();
24028 }
24029
24030 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24031 return SWIG_Python_InitShadowInstance(args);
24032 }
24033
24034 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24035 PyObject *resultobj = 0;
24036 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24037 int arg2 = (int) 0 ;
24038 wxCloseEvent *result = 0 ;
24039 int val1 ;
24040 int ecode1 = 0 ;
24041 int val2 ;
24042 int ecode2 = 0 ;
24043 PyObject * obj0 = 0 ;
24044 PyObject * obj1 = 0 ;
24045 char * kwnames[] = {
24046 (char *) "type",(char *) "winid", NULL
24047 };
24048
24049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24050 if (obj0) {
24051 ecode1 = SWIG_AsVal_int(obj0, &val1);
24052 if (!SWIG_IsOK(ecode1)) {
24053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24054 }
24055 arg1 = static_cast< wxEventType >(val1);
24056 }
24057 if (obj1) {
24058 ecode2 = SWIG_AsVal_int(obj1, &val2);
24059 if (!SWIG_IsOK(ecode2)) {
24060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24061 }
24062 arg2 = static_cast< int >(val2);
24063 }
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24071 return resultobj;
24072 fail:
24073 return NULL;
24074 }
24075
24076
24077 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24078 PyObject *resultobj = 0;
24079 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24080 bool arg2 ;
24081 void *argp1 = 0 ;
24082 int res1 = 0 ;
24083 bool val2 ;
24084 int ecode2 = 0 ;
24085 PyObject * obj0 = 0 ;
24086 PyObject * obj1 = 0 ;
24087 char * kwnames[] = {
24088 (char *) "self",(char *) "logOff", NULL
24089 };
24090
24091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24093 if (!SWIG_IsOK(res1)) {
24094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24095 }
24096 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24097 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24098 if (!SWIG_IsOK(ecode2)) {
24099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24100 }
24101 arg2 = static_cast< bool >(val2);
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 (arg1)->SetLoggingOff(arg2);
24105 wxPyEndAllowThreads(__tstate);
24106 if (PyErr_Occurred()) SWIG_fail;
24107 }
24108 resultobj = SWIG_Py_Void();
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 PyObject *resultobj = 0;
24117 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24118 bool result;
24119 void *argp1 = 0 ;
24120 int res1 = 0 ;
24121 PyObject *swig_obj[1] ;
24122
24123 if (!args) SWIG_fail;
24124 swig_obj[0] = args;
24125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24126 if (!SWIG_IsOK(res1)) {
24127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24128 }
24129 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24133 wxPyEndAllowThreads(__tstate);
24134 if (PyErr_Occurred()) SWIG_fail;
24135 }
24136 {
24137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24138 }
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24146 PyObject *resultobj = 0;
24147 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24148 bool arg2 = (bool) true ;
24149 void *argp1 = 0 ;
24150 int res1 = 0 ;
24151 bool val2 ;
24152 int ecode2 = 0 ;
24153 PyObject * obj0 = 0 ;
24154 PyObject * obj1 = 0 ;
24155 char * kwnames[] = {
24156 (char *) "self",(char *) "veto", NULL
24157 };
24158
24159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24161 if (!SWIG_IsOK(res1)) {
24162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24163 }
24164 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24165 if (obj1) {
24166 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24167 if (!SWIG_IsOK(ecode2)) {
24168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24169 }
24170 arg2 = static_cast< bool >(val2);
24171 }
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 (arg1)->Veto(arg2);
24175 wxPyEndAllowThreads(__tstate);
24176 if (PyErr_Occurred()) SWIG_fail;
24177 }
24178 resultobj = SWIG_Py_Void();
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24186 PyObject *resultobj = 0;
24187 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24188 bool result;
24189 void *argp1 = 0 ;
24190 int res1 = 0 ;
24191 PyObject *swig_obj[1] ;
24192
24193 if (!args) SWIG_fail;
24194 swig_obj[0] = args;
24195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24196 if (!SWIG_IsOK(res1)) {
24197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24198 }
24199 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 {
24207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24208 }
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24216 PyObject *resultobj = 0;
24217 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24218 bool arg2 ;
24219 void *argp1 = 0 ;
24220 int res1 = 0 ;
24221 bool val2 ;
24222 int ecode2 = 0 ;
24223 PyObject * obj0 = 0 ;
24224 PyObject * obj1 = 0 ;
24225 char * kwnames[] = {
24226 (char *) "self",(char *) "canVeto", NULL
24227 };
24228
24229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24231 if (!SWIG_IsOK(res1)) {
24232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24233 }
24234 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24235 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24236 if (!SWIG_IsOK(ecode2)) {
24237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24238 }
24239 arg2 = static_cast< bool >(val2);
24240 {
24241 PyThreadState* __tstate = wxPyBeginAllowThreads();
24242 (arg1)->SetCanVeto(arg2);
24243 wxPyEndAllowThreads(__tstate);
24244 if (PyErr_Occurred()) SWIG_fail;
24245 }
24246 resultobj = SWIG_Py_Void();
24247 return resultobj;
24248 fail:
24249 return NULL;
24250 }
24251
24252
24253 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24254 PyObject *resultobj = 0;
24255 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24256 bool result;
24257 void *argp1 = 0 ;
24258 int res1 = 0 ;
24259 PyObject *swig_obj[1] ;
24260
24261 if (!args) SWIG_fail;
24262 swig_obj[0] = args;
24263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24264 if (!SWIG_IsOK(res1)) {
24265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24266 }
24267 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 {
24275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24276 }
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24284 PyObject *obj;
24285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24286 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24287 return SWIG_Py_Void();
24288 }
24289
24290 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24291 return SWIG_Python_InitShadowInstance(args);
24292 }
24293
24294 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24295 PyObject *resultobj = 0;
24296 int arg1 = (int) 0 ;
24297 bool arg2 = (bool) false ;
24298 wxShowEvent *result = 0 ;
24299 int val1 ;
24300 int ecode1 = 0 ;
24301 bool val2 ;
24302 int ecode2 = 0 ;
24303 PyObject * obj0 = 0 ;
24304 PyObject * obj1 = 0 ;
24305 char * kwnames[] = {
24306 (char *) "winid",(char *) "show", NULL
24307 };
24308
24309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24310 if (obj0) {
24311 ecode1 = SWIG_AsVal_int(obj0, &val1);
24312 if (!SWIG_IsOK(ecode1)) {
24313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24314 }
24315 arg1 = static_cast< int >(val1);
24316 }
24317 if (obj1) {
24318 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24319 if (!SWIG_IsOK(ecode2)) {
24320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24321 }
24322 arg2 = static_cast< bool >(val2);
24323 }
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24331 return resultobj;
24332 fail:
24333 return NULL;
24334 }
24335
24336
24337 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24338 PyObject *resultobj = 0;
24339 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24340 bool arg2 ;
24341 void *argp1 = 0 ;
24342 int res1 = 0 ;
24343 bool val2 ;
24344 int ecode2 = 0 ;
24345 PyObject * obj0 = 0 ;
24346 PyObject * obj1 = 0 ;
24347 char * kwnames[] = {
24348 (char *) "self",(char *) "show", NULL
24349 };
24350
24351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24353 if (!SWIG_IsOK(res1)) {
24354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24355 }
24356 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24357 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24358 if (!SWIG_IsOK(ecode2)) {
24359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24360 }
24361 arg2 = static_cast< bool >(val2);
24362 {
24363 PyThreadState* __tstate = wxPyBeginAllowThreads();
24364 (arg1)->SetShow(arg2);
24365 wxPyEndAllowThreads(__tstate);
24366 if (PyErr_Occurred()) SWIG_fail;
24367 }
24368 resultobj = SWIG_Py_Void();
24369 return resultobj;
24370 fail:
24371 return NULL;
24372 }
24373
24374
24375 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24376 PyObject *resultobj = 0;
24377 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24378 bool result;
24379 void *argp1 = 0 ;
24380 int res1 = 0 ;
24381 PyObject *swig_obj[1] ;
24382
24383 if (!args) SWIG_fail;
24384 swig_obj[0] = args;
24385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24386 if (!SWIG_IsOK(res1)) {
24387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24388 }
24389 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 {
24397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24398 }
24399 return resultobj;
24400 fail:
24401 return NULL;
24402 }
24403
24404
24405 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24406 PyObject *obj;
24407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24408 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24409 return SWIG_Py_Void();
24410 }
24411
24412 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24413 return SWIG_Python_InitShadowInstance(args);
24414 }
24415
24416 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24417 PyObject *resultobj = 0;
24418 int arg1 = (int) 0 ;
24419 bool arg2 = (bool) true ;
24420 wxIconizeEvent *result = 0 ;
24421 int val1 ;
24422 int ecode1 = 0 ;
24423 bool val2 ;
24424 int ecode2 = 0 ;
24425 PyObject * obj0 = 0 ;
24426 PyObject * obj1 = 0 ;
24427 char * kwnames[] = {
24428 (char *) "id",(char *) "iconized", NULL
24429 };
24430
24431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24432 if (obj0) {
24433 ecode1 = SWIG_AsVal_int(obj0, &val1);
24434 if (!SWIG_IsOK(ecode1)) {
24435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24436 }
24437 arg1 = static_cast< int >(val1);
24438 }
24439 if (obj1) {
24440 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24441 if (!SWIG_IsOK(ecode2)) {
24442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24443 }
24444 arg2 = static_cast< bool >(val2);
24445 }
24446 {
24447 PyThreadState* __tstate = wxPyBeginAllowThreads();
24448 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24449 wxPyEndAllowThreads(__tstate);
24450 if (PyErr_Occurred()) SWIG_fail;
24451 }
24452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24460 PyObject *resultobj = 0;
24461 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24462 bool result;
24463 void *argp1 = 0 ;
24464 int res1 = 0 ;
24465 PyObject *swig_obj[1] ;
24466
24467 if (!args) SWIG_fail;
24468 swig_obj[0] = args;
24469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24470 if (!SWIG_IsOK(res1)) {
24471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24472 }
24473 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 result = (bool)(arg1)->Iconized();
24477 wxPyEndAllowThreads(__tstate);
24478 if (PyErr_Occurred()) SWIG_fail;
24479 }
24480 {
24481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24482 }
24483 return resultobj;
24484 fail:
24485 return NULL;
24486 }
24487
24488
24489 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24490 PyObject *obj;
24491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24492 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24493 return SWIG_Py_Void();
24494 }
24495
24496 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24497 return SWIG_Python_InitShadowInstance(args);
24498 }
24499
24500 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24501 PyObject *resultobj = 0;
24502 int arg1 = (int) 0 ;
24503 wxMaximizeEvent *result = 0 ;
24504 int val1 ;
24505 int ecode1 = 0 ;
24506 PyObject * obj0 = 0 ;
24507 char * kwnames[] = {
24508 (char *) "id", NULL
24509 };
24510
24511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24512 if (obj0) {
24513 ecode1 = SWIG_AsVal_int(obj0, &val1);
24514 if (!SWIG_IsOK(ecode1)) {
24515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24516 }
24517 arg1 = static_cast< int >(val1);
24518 }
24519 {
24520 PyThreadState* __tstate = wxPyBeginAllowThreads();
24521 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24522 wxPyEndAllowThreads(__tstate);
24523 if (PyErr_Occurred()) SWIG_fail;
24524 }
24525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24533 PyObject *obj;
24534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24535 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24536 return SWIG_Py_Void();
24537 }
24538
24539 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24540 return SWIG_Python_InitShadowInstance(args);
24541 }
24542
24543 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24544 PyObject *resultobj = 0;
24545 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24546 wxPoint result;
24547 void *argp1 = 0 ;
24548 int res1 = 0 ;
24549 PyObject *swig_obj[1] ;
24550
24551 if (!args) SWIG_fail;
24552 swig_obj[0] = args;
24553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24554 if (!SWIG_IsOK(res1)) {
24555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24556 }
24557 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24558 {
24559 PyThreadState* __tstate = wxPyBeginAllowThreads();
24560 result = (arg1)->GetPosition();
24561 wxPyEndAllowThreads(__tstate);
24562 if (PyErr_Occurred()) SWIG_fail;
24563 }
24564 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24565 return resultobj;
24566 fail:
24567 return NULL;
24568 }
24569
24570
24571 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24572 PyObject *resultobj = 0;
24573 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24574 int result;
24575 void *argp1 = 0 ;
24576 int res1 = 0 ;
24577 PyObject *swig_obj[1] ;
24578
24579 if (!args) SWIG_fail;
24580 swig_obj[0] = args;
24581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24582 if (!SWIG_IsOK(res1)) {
24583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24584 }
24585 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 result = (int)(arg1)->GetNumberOfFiles();
24589 wxPyEndAllowThreads(__tstate);
24590 if (PyErr_Occurred()) SWIG_fail;
24591 }
24592 resultobj = SWIG_From_int(static_cast< int >(result));
24593 return resultobj;
24594 fail:
24595 return NULL;
24596 }
24597
24598
24599 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 PyObject *resultobj = 0;
24601 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24602 PyObject *result = 0 ;
24603 void *argp1 = 0 ;
24604 int res1 = 0 ;
24605 PyObject *swig_obj[1] ;
24606
24607 if (!args) SWIG_fail;
24608 swig_obj[0] = args;
24609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24610 if (!SWIG_IsOK(res1)) {
24611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24612 }
24613 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24617 wxPyEndAllowThreads(__tstate);
24618 if (PyErr_Occurred()) SWIG_fail;
24619 }
24620 resultobj = result;
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24628 PyObject *obj;
24629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24630 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24631 return SWIG_Py_Void();
24632 }
24633
24634 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24635 PyObject *resultobj = 0;
24636 int arg1 = (int) 0 ;
24637 wxUpdateUIEvent *result = 0 ;
24638 int val1 ;
24639 int ecode1 = 0 ;
24640 PyObject * obj0 = 0 ;
24641 char * kwnames[] = {
24642 (char *) "commandId", NULL
24643 };
24644
24645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24646 if (obj0) {
24647 ecode1 = SWIG_AsVal_int(obj0, &val1);
24648 if (!SWIG_IsOK(ecode1)) {
24649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24650 }
24651 arg1 = static_cast< int >(val1);
24652 }
24653 {
24654 PyThreadState* __tstate = wxPyBeginAllowThreads();
24655 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24656 wxPyEndAllowThreads(__tstate);
24657 if (PyErr_Occurred()) SWIG_fail;
24658 }
24659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24660 return resultobj;
24661 fail:
24662 return NULL;
24663 }
24664
24665
24666 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24667 PyObject *resultobj = 0;
24668 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24669 bool result;
24670 void *argp1 = 0 ;
24671 int res1 = 0 ;
24672 PyObject *swig_obj[1] ;
24673
24674 if (!args) SWIG_fail;
24675 swig_obj[0] = args;
24676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24677 if (!SWIG_IsOK(res1)) {
24678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24679 }
24680 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24681 {
24682 PyThreadState* __tstate = wxPyBeginAllowThreads();
24683 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24684 wxPyEndAllowThreads(__tstate);
24685 if (PyErr_Occurred()) SWIG_fail;
24686 }
24687 {
24688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24689 }
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24697 PyObject *resultobj = 0;
24698 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24699 bool result;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 PyObject *swig_obj[1] ;
24703
24704 if (!args) SWIG_fail;
24705 swig_obj[0] = args;
24706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24707 if (!SWIG_IsOK(res1)) {
24708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24709 }
24710 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 {
24718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24719 }
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24727 PyObject *resultobj = 0;
24728 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24729 bool result;
24730 void *argp1 = 0 ;
24731 int res1 = 0 ;
24732 PyObject *swig_obj[1] ;
24733
24734 if (!args) SWIG_fail;
24735 swig_obj[0] = args;
24736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24737 if (!SWIG_IsOK(res1)) {
24738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24739 }
24740 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 {
24748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24749 }
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24757 PyObject *resultobj = 0;
24758 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24759 wxString result;
24760 void *argp1 = 0 ;
24761 int res1 = 0 ;
24762 PyObject *swig_obj[1] ;
24763
24764 if (!args) SWIG_fail;
24765 swig_obj[0] = args;
24766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24767 if (!SWIG_IsOK(res1)) {
24768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24769 }
24770 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24771 {
24772 PyThreadState* __tstate = wxPyBeginAllowThreads();
24773 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 {
24778 #if wxUSE_UNICODE
24779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24780 #else
24781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24782 #endif
24783 }
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24791 PyObject *resultobj = 0;
24792 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 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_wxUpdateUIEvent, 0 | 0 );
24801 if (!SWIG_IsOK(res1)) {
24802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24803 }
24804 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24805 {
24806 PyThreadState* __tstate = wxPyBeginAllowThreads();
24807 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
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 *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24821 PyObject *resultobj = 0;
24822 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24823 bool result;
24824 void *argp1 = 0 ;
24825 int res1 = 0 ;
24826 PyObject *swig_obj[1] ;
24827
24828 if (!args) SWIG_fail;
24829 swig_obj[0] = args;
24830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24831 if (!SWIG_IsOK(res1)) {
24832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24833 }
24834 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 {
24842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24843 }
24844 return resultobj;
24845 fail:
24846 return NULL;
24847 }
24848
24849
24850 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24851 PyObject *resultobj = 0;
24852 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24853 bool result;
24854 void *argp1 = 0 ;
24855 int res1 = 0 ;
24856 PyObject *swig_obj[1] ;
24857
24858 if (!args) SWIG_fail;
24859 swig_obj[0] = args;
24860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24861 if (!SWIG_IsOK(res1)) {
24862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24863 }
24864 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 {
24872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24873 }
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24881 PyObject *resultobj = 0;
24882 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24883 bool result;
24884 void *argp1 = 0 ;
24885 int res1 = 0 ;
24886 PyObject *swig_obj[1] ;
24887
24888 if (!args) SWIG_fail;
24889 swig_obj[0] = args;
24890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24891 if (!SWIG_IsOK(res1)) {
24892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24893 }
24894 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24895 {
24896 PyThreadState* __tstate = wxPyBeginAllowThreads();
24897 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24898 wxPyEndAllowThreads(__tstate);
24899 if (PyErr_Occurred()) SWIG_fail;
24900 }
24901 {
24902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24903 }
24904 return resultobj;
24905 fail:
24906 return NULL;
24907 }
24908
24909
24910 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24911 PyObject *resultobj = 0;
24912 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24913 bool arg2 ;
24914 void *argp1 = 0 ;
24915 int res1 = 0 ;
24916 bool val2 ;
24917 int ecode2 = 0 ;
24918 PyObject * obj0 = 0 ;
24919 PyObject * obj1 = 0 ;
24920 char * kwnames[] = {
24921 (char *) "self",(char *) "check", NULL
24922 };
24923
24924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24926 if (!SWIG_IsOK(res1)) {
24927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24928 }
24929 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24931 if (!SWIG_IsOK(ecode2)) {
24932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24933 }
24934 arg2 = static_cast< bool >(val2);
24935 {
24936 PyThreadState* __tstate = wxPyBeginAllowThreads();
24937 (arg1)->Check(arg2);
24938 wxPyEndAllowThreads(__tstate);
24939 if (PyErr_Occurred()) SWIG_fail;
24940 }
24941 resultobj = SWIG_Py_Void();
24942 return resultobj;
24943 fail:
24944 return NULL;
24945 }
24946
24947
24948 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24949 PyObject *resultobj = 0;
24950 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24951 bool arg2 ;
24952 void *argp1 = 0 ;
24953 int res1 = 0 ;
24954 bool val2 ;
24955 int ecode2 = 0 ;
24956 PyObject * obj0 = 0 ;
24957 PyObject * obj1 = 0 ;
24958 char * kwnames[] = {
24959 (char *) "self",(char *) "enable", NULL
24960 };
24961
24962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24964 if (!SWIG_IsOK(res1)) {
24965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24966 }
24967 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24969 if (!SWIG_IsOK(ecode2)) {
24970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24971 }
24972 arg2 = static_cast< bool >(val2);
24973 {
24974 PyThreadState* __tstate = wxPyBeginAllowThreads();
24975 (arg1)->Enable(arg2);
24976 wxPyEndAllowThreads(__tstate);
24977 if (PyErr_Occurred()) SWIG_fail;
24978 }
24979 resultobj = SWIG_Py_Void();
24980 return resultobj;
24981 fail:
24982 return NULL;
24983 }
24984
24985
24986 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24987 PyObject *resultobj = 0;
24988 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24989 bool arg2 ;
24990 void *argp1 = 0 ;
24991 int res1 = 0 ;
24992 bool val2 ;
24993 int ecode2 = 0 ;
24994 PyObject * obj0 = 0 ;
24995 PyObject * obj1 = 0 ;
24996 char * kwnames[] = {
24997 (char *) "self",(char *) "show", NULL
24998 };
24999
25000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25002 if (!SWIG_IsOK(res1)) {
25003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25004 }
25005 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25006 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25007 if (!SWIG_IsOK(ecode2)) {
25008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25009 }
25010 arg2 = static_cast< bool >(val2);
25011 {
25012 PyThreadState* __tstate = wxPyBeginAllowThreads();
25013 (arg1)->Show(arg2);
25014 wxPyEndAllowThreads(__tstate);
25015 if (PyErr_Occurred()) SWIG_fail;
25016 }
25017 resultobj = SWIG_Py_Void();
25018 return resultobj;
25019 fail:
25020 return NULL;
25021 }
25022
25023
25024 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25025 PyObject *resultobj = 0;
25026 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25027 wxString *arg2 = 0 ;
25028 void *argp1 = 0 ;
25029 int res1 = 0 ;
25030 bool temp2 = false ;
25031 PyObject * obj0 = 0 ;
25032 PyObject * obj1 = 0 ;
25033 char * kwnames[] = {
25034 (char *) "self",(char *) "text", NULL
25035 };
25036
25037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25039 if (!SWIG_IsOK(res1)) {
25040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25041 }
25042 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25043 {
25044 arg2 = wxString_in_helper(obj1);
25045 if (arg2 == NULL) SWIG_fail;
25046 temp2 = true;
25047 }
25048 {
25049 PyThreadState* __tstate = wxPyBeginAllowThreads();
25050 (arg1)->SetText((wxString const &)*arg2);
25051 wxPyEndAllowThreads(__tstate);
25052 if (PyErr_Occurred()) SWIG_fail;
25053 }
25054 resultobj = SWIG_Py_Void();
25055 {
25056 if (temp2)
25057 delete arg2;
25058 }
25059 return resultobj;
25060 fail:
25061 {
25062 if (temp2)
25063 delete arg2;
25064 }
25065 return NULL;
25066 }
25067
25068
25069 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25070 PyObject *resultobj = 0;
25071 long arg1 ;
25072 long val1 ;
25073 int ecode1 = 0 ;
25074 PyObject * obj0 = 0 ;
25075 char * kwnames[] = {
25076 (char *) "updateInterval", NULL
25077 };
25078
25079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25080 ecode1 = SWIG_AsVal_long(obj0, &val1);
25081 if (!SWIG_IsOK(ecode1)) {
25082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25083 }
25084 arg1 = static_cast< long >(val1);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 wxUpdateUIEvent::SetUpdateInterval(arg1);
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_Py_Void();
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25099 PyObject *resultobj = 0;
25100 long result;
25101
25102 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25103 {
25104 PyThreadState* __tstate = wxPyBeginAllowThreads();
25105 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25106 wxPyEndAllowThreads(__tstate);
25107 if (PyErr_Occurred()) SWIG_fail;
25108 }
25109 resultobj = SWIG_From_long(static_cast< long >(result));
25110 return resultobj;
25111 fail:
25112 return NULL;
25113 }
25114
25115
25116 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25117 PyObject *resultobj = 0;
25118 wxWindow *arg1 = (wxWindow *) 0 ;
25119 bool result;
25120 void *argp1 = 0 ;
25121 int res1 = 0 ;
25122 PyObject * obj0 = 0 ;
25123 char * kwnames[] = {
25124 (char *) "win", NULL
25125 };
25126
25127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25129 if (!SWIG_IsOK(res1)) {
25130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25131 }
25132 arg1 = reinterpret_cast< wxWindow * >(argp1);
25133 {
25134 PyThreadState* __tstate = wxPyBeginAllowThreads();
25135 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25136 wxPyEndAllowThreads(__tstate);
25137 if (PyErr_Occurred()) SWIG_fail;
25138 }
25139 {
25140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25141 }
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25149 PyObject *resultobj = 0;
25150
25151 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 wxUpdateUIEvent::ResetUpdateTime();
25155 wxPyEndAllowThreads(__tstate);
25156 if (PyErr_Occurred()) SWIG_fail;
25157 }
25158 resultobj = SWIG_Py_Void();
25159 return resultobj;
25160 fail:
25161 return NULL;
25162 }
25163
25164
25165 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25166 PyObject *resultobj = 0;
25167 wxUpdateUIMode arg1 ;
25168 int val1 ;
25169 int ecode1 = 0 ;
25170 PyObject * obj0 = 0 ;
25171 char * kwnames[] = {
25172 (char *) "mode", NULL
25173 };
25174
25175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25176 ecode1 = SWIG_AsVal_int(obj0, &val1);
25177 if (!SWIG_IsOK(ecode1)) {
25178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25179 }
25180 arg1 = static_cast< wxUpdateUIMode >(val1);
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 wxUpdateUIEvent::SetMode(arg1);
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 resultobj = SWIG_Py_Void();
25188 return resultobj;
25189 fail:
25190 return NULL;
25191 }
25192
25193
25194 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25195 PyObject *resultobj = 0;
25196 wxUpdateUIMode result;
25197
25198 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25199 {
25200 PyThreadState* __tstate = wxPyBeginAllowThreads();
25201 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25202 wxPyEndAllowThreads(__tstate);
25203 if (PyErr_Occurred()) SWIG_fail;
25204 }
25205 resultobj = SWIG_From_int(static_cast< int >(result));
25206 return resultobj;
25207 fail:
25208 return NULL;
25209 }
25210
25211
25212 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25213 PyObject *obj;
25214 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25215 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25216 return SWIG_Py_Void();
25217 }
25218
25219 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25220 return SWIG_Python_InitShadowInstance(args);
25221 }
25222
25223 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25224 PyObject *resultobj = 0;
25225 wxSysColourChangedEvent *result = 0 ;
25226
25227 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25228 {
25229 PyThreadState* __tstate = wxPyBeginAllowThreads();
25230 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25231 wxPyEndAllowThreads(__tstate);
25232 if (PyErr_Occurred()) SWIG_fail;
25233 }
25234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25235 return resultobj;
25236 fail:
25237 return NULL;
25238 }
25239
25240
25241 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25242 PyObject *obj;
25243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25244 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25245 return SWIG_Py_Void();
25246 }
25247
25248 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25249 return SWIG_Python_InitShadowInstance(args);
25250 }
25251
25252 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj = 0;
25254 int arg1 = (int) 0 ;
25255 wxWindow *arg2 = (wxWindow *) NULL ;
25256 wxMouseCaptureChangedEvent *result = 0 ;
25257 int val1 ;
25258 int ecode1 = 0 ;
25259 void *argp2 = 0 ;
25260 int res2 = 0 ;
25261 PyObject * obj0 = 0 ;
25262 PyObject * obj1 = 0 ;
25263 char * kwnames[] = {
25264 (char *) "winid",(char *) "gainedCapture", NULL
25265 };
25266
25267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25268 if (obj0) {
25269 ecode1 = SWIG_AsVal_int(obj0, &val1);
25270 if (!SWIG_IsOK(ecode1)) {
25271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25272 }
25273 arg1 = static_cast< int >(val1);
25274 }
25275 if (obj1) {
25276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25277 if (!SWIG_IsOK(res2)) {
25278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25279 }
25280 arg2 = reinterpret_cast< wxWindow * >(argp2);
25281 }
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25296 PyObject *resultobj = 0;
25297 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25298 wxWindow *result = 0 ;
25299 void *argp1 = 0 ;
25300 int res1 = 0 ;
25301 PyObject *swig_obj[1] ;
25302
25303 if (!args) SWIG_fail;
25304 swig_obj[0] = args;
25305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25306 if (!SWIG_IsOK(res1)) {
25307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25308 }
25309 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 {
25317 resultobj = wxPyMake_wxObject(result, (bool)0);
25318 }
25319 return resultobj;
25320 fail:
25321 return NULL;
25322 }
25323
25324
25325 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25326 PyObject *obj;
25327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25328 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25329 return SWIG_Py_Void();
25330 }
25331
25332 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25333 return SWIG_Python_InitShadowInstance(args);
25334 }
25335
25336 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25337 PyObject *resultobj = 0;
25338 wxDisplayChangedEvent *result = 0 ;
25339
25340 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25341 {
25342 PyThreadState* __tstate = wxPyBeginAllowThreads();
25343 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25344 wxPyEndAllowThreads(__tstate);
25345 if (PyErr_Occurred()) SWIG_fail;
25346 }
25347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25348 return resultobj;
25349 fail:
25350 return NULL;
25351 }
25352
25353
25354 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25355 PyObject *obj;
25356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25357 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25358 return SWIG_Py_Void();
25359 }
25360
25361 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25362 return SWIG_Python_InitShadowInstance(args);
25363 }
25364
25365 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25366 PyObject *resultobj = 0;
25367 int arg1 = (int) 0 ;
25368 wxPaletteChangedEvent *result = 0 ;
25369 int val1 ;
25370 int ecode1 = 0 ;
25371 PyObject * obj0 = 0 ;
25372 char * kwnames[] = {
25373 (char *) "id", NULL
25374 };
25375
25376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25377 if (obj0) {
25378 ecode1 = SWIG_AsVal_int(obj0, &val1);
25379 if (!SWIG_IsOK(ecode1)) {
25380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25381 }
25382 arg1 = static_cast< int >(val1);
25383 }
25384 {
25385 PyThreadState* __tstate = wxPyBeginAllowThreads();
25386 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25398 PyObject *resultobj = 0;
25399 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25400 wxWindow *arg2 = (wxWindow *) 0 ;
25401 void *argp1 = 0 ;
25402 int res1 = 0 ;
25403 void *argp2 = 0 ;
25404 int res2 = 0 ;
25405 PyObject * obj0 = 0 ;
25406 PyObject * obj1 = 0 ;
25407 char * kwnames[] = {
25408 (char *) "self",(char *) "win", NULL
25409 };
25410
25411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25413 if (!SWIG_IsOK(res1)) {
25414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25415 }
25416 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25418 if (!SWIG_IsOK(res2)) {
25419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25420 }
25421 arg2 = reinterpret_cast< wxWindow * >(argp2);
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 (arg1)->SetChangedWindow(arg2);
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_Py_Void();
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25436 PyObject *resultobj = 0;
25437 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25438 wxWindow *result = 0 ;
25439 void *argp1 = 0 ;
25440 int res1 = 0 ;
25441 PyObject *swig_obj[1] ;
25442
25443 if (!args) SWIG_fail;
25444 swig_obj[0] = args;
25445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25446 if (!SWIG_IsOK(res1)) {
25447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25448 }
25449 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25450 {
25451 PyThreadState* __tstate = wxPyBeginAllowThreads();
25452 result = (wxWindow *)(arg1)->GetChangedWindow();
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 {
25457 resultobj = wxPyMake_wxObject(result, (bool)0);
25458 }
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 PyObject *obj;
25467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25468 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25469 return SWIG_Py_Void();
25470 }
25471
25472 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25473 return SWIG_Python_InitShadowInstance(args);
25474 }
25475
25476 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj = 0;
25478 int arg1 = (int) 0 ;
25479 wxQueryNewPaletteEvent *result = 0 ;
25480 int val1 ;
25481 int ecode1 = 0 ;
25482 PyObject * obj0 = 0 ;
25483 char * kwnames[] = {
25484 (char *) "winid", NULL
25485 };
25486
25487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25488 if (obj0) {
25489 ecode1 = SWIG_AsVal_int(obj0, &val1);
25490 if (!SWIG_IsOK(ecode1)) {
25491 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25492 }
25493 arg1 = static_cast< int >(val1);
25494 }
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25498 wxPyEndAllowThreads(__tstate);
25499 if (PyErr_Occurred()) SWIG_fail;
25500 }
25501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25502 return resultobj;
25503 fail:
25504 return NULL;
25505 }
25506
25507
25508 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25509 PyObject *resultobj = 0;
25510 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25511 bool arg2 ;
25512 void *argp1 = 0 ;
25513 int res1 = 0 ;
25514 bool val2 ;
25515 int ecode2 = 0 ;
25516 PyObject * obj0 = 0 ;
25517 PyObject * obj1 = 0 ;
25518 char * kwnames[] = {
25519 (char *) "self",(char *) "realized", NULL
25520 };
25521
25522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25524 if (!SWIG_IsOK(res1)) {
25525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25526 }
25527 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25529 if (!SWIG_IsOK(ecode2)) {
25530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25531 }
25532 arg2 = static_cast< bool >(val2);
25533 {
25534 PyThreadState* __tstate = wxPyBeginAllowThreads();
25535 (arg1)->SetPaletteRealized(arg2);
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 resultobj = SWIG_Py_Void();
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25547 PyObject *resultobj = 0;
25548 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25549 bool result;
25550 void *argp1 = 0 ;
25551 int res1 = 0 ;
25552 PyObject *swig_obj[1] ;
25553
25554 if (!args) SWIG_fail;
25555 swig_obj[0] = args;
25556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25557 if (!SWIG_IsOK(res1)) {
25558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25559 }
25560 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25564 wxPyEndAllowThreads(__tstate);
25565 if (PyErr_Occurred()) SWIG_fail;
25566 }
25567 {
25568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25569 }
25570 return resultobj;
25571 fail:
25572 return NULL;
25573 }
25574
25575
25576 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25577 PyObject *obj;
25578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25579 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25580 return SWIG_Py_Void();
25581 }
25582
25583 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584 return SWIG_Python_InitShadowInstance(args);
25585 }
25586
25587 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25588 PyObject *resultobj = 0;
25589 wxNavigationKeyEvent *result = 0 ;
25590
25591 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25606 PyObject *resultobj = 0;
25607 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25608 bool result;
25609 void *argp1 = 0 ;
25610 int res1 = 0 ;
25611 PyObject *swig_obj[1] ;
25612
25613 if (!args) SWIG_fail;
25614 swig_obj[0] = args;
25615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25616 if (!SWIG_IsOK(res1)) {
25617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25618 }
25619 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25620 {
25621 PyThreadState* __tstate = wxPyBeginAllowThreads();
25622 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25623 wxPyEndAllowThreads(__tstate);
25624 if (PyErr_Occurred()) SWIG_fail;
25625 }
25626 {
25627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25628 }
25629 return resultobj;
25630 fail:
25631 return NULL;
25632 }
25633
25634
25635 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25636 PyObject *resultobj = 0;
25637 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25638 bool arg2 ;
25639 void *argp1 = 0 ;
25640 int res1 = 0 ;
25641 bool val2 ;
25642 int ecode2 = 0 ;
25643 PyObject * obj0 = 0 ;
25644 PyObject * obj1 = 0 ;
25645 char * kwnames[] = {
25646 (char *) "self",(char *) "forward", NULL
25647 };
25648
25649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25651 if (!SWIG_IsOK(res1)) {
25652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25653 }
25654 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25655 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25656 if (!SWIG_IsOK(ecode2)) {
25657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25658 }
25659 arg2 = static_cast< bool >(val2);
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 (arg1)->SetDirection(arg2);
25663 wxPyEndAllowThreads(__tstate);
25664 if (PyErr_Occurred()) SWIG_fail;
25665 }
25666 resultobj = SWIG_Py_Void();
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25676 bool result;
25677 void *argp1 = 0 ;
25678 int res1 = 0 ;
25679 PyObject *swig_obj[1] ;
25680
25681 if (!args) SWIG_fail;
25682 swig_obj[0] = args;
25683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25684 if (!SWIG_IsOK(res1)) {
25685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25686 }
25687 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 {
25695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25696 }
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25704 PyObject *resultobj = 0;
25705 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25706 bool arg2 ;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 bool val2 ;
25710 int ecode2 = 0 ;
25711 PyObject * obj0 = 0 ;
25712 PyObject * obj1 = 0 ;
25713 char * kwnames[] = {
25714 (char *) "self",(char *) "ischange", NULL
25715 };
25716
25717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25719 if (!SWIG_IsOK(res1)) {
25720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25721 }
25722 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25724 if (!SWIG_IsOK(ecode2)) {
25725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25726 }
25727 arg2 = static_cast< bool >(val2);
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 (arg1)->SetWindowChange(arg2);
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 resultobj = SWIG_Py_Void();
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25742 PyObject *resultobj = 0;
25743 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25744 bool result;
25745 void *argp1 = 0 ;
25746 int res1 = 0 ;
25747 PyObject *swig_obj[1] ;
25748
25749 if (!args) SWIG_fail;
25750 swig_obj[0] = args;
25751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25752 if (!SWIG_IsOK(res1)) {
25753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25754 }
25755 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25759 wxPyEndAllowThreads(__tstate);
25760 if (PyErr_Occurred()) SWIG_fail;
25761 }
25762 {
25763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25764 }
25765 return resultobj;
25766 fail:
25767 return NULL;
25768 }
25769
25770
25771 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25772 PyObject *resultobj = 0;
25773 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25774 bool arg2 ;
25775 void *argp1 = 0 ;
25776 int res1 = 0 ;
25777 bool val2 ;
25778 int ecode2 = 0 ;
25779 PyObject * obj0 = 0 ;
25780 PyObject * obj1 = 0 ;
25781 char * kwnames[] = {
25782 (char *) "self",(char *) "bIs", NULL
25783 };
25784
25785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25787 if (!SWIG_IsOK(res1)) {
25788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25789 }
25790 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25791 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25792 if (!SWIG_IsOK(ecode2)) {
25793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25794 }
25795 arg2 = static_cast< bool >(val2);
25796 {
25797 PyThreadState* __tstate = wxPyBeginAllowThreads();
25798 (arg1)->SetFromTab(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_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25810 PyObject *resultobj = 0;
25811 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25812 long arg2 ;
25813 void *argp1 = 0 ;
25814 int res1 = 0 ;
25815 long val2 ;
25816 int ecode2 = 0 ;
25817 PyObject * obj0 = 0 ;
25818 PyObject * obj1 = 0 ;
25819 char * kwnames[] = {
25820 (char *) "self",(char *) "flags", NULL
25821 };
25822
25823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25825 if (!SWIG_IsOK(res1)) {
25826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25827 }
25828 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25829 ecode2 = SWIG_AsVal_long(obj1, &val2);
25830 if (!SWIG_IsOK(ecode2)) {
25831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25832 }
25833 arg2 = static_cast< long >(val2);
25834 {
25835 PyThreadState* __tstate = wxPyBeginAllowThreads();
25836 (arg1)->SetFlags(arg2);
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 resultobj = SWIG_Py_Void();
25841 return resultobj;
25842 fail:
25843 return NULL;
25844 }
25845
25846
25847 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25848 PyObject *resultobj = 0;
25849 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25850 wxWindow *result = 0 ;
25851 void *argp1 = 0 ;
25852 int res1 = 0 ;
25853 PyObject *swig_obj[1] ;
25854
25855 if (!args) SWIG_fail;
25856 swig_obj[0] = args;
25857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25858 if (!SWIG_IsOK(res1)) {
25859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25860 }
25861 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25862 {
25863 PyThreadState* __tstate = wxPyBeginAllowThreads();
25864 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 {
25869 resultobj = wxPyMake_wxObject(result, (bool)0);
25870 }
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj = 0;
25879 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25880 wxWindow *arg2 = (wxWindow *) 0 ;
25881 void *argp1 = 0 ;
25882 int res1 = 0 ;
25883 void *argp2 = 0 ;
25884 int res2 = 0 ;
25885 PyObject * obj0 = 0 ;
25886 PyObject * obj1 = 0 ;
25887 char * kwnames[] = {
25888 (char *) "self",(char *) "win", NULL
25889 };
25890
25891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25893 if (!SWIG_IsOK(res1)) {
25894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25895 }
25896 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25897 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25898 if (!SWIG_IsOK(res2)) {
25899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25900 }
25901 arg2 = reinterpret_cast< wxWindow * >(argp2);
25902 {
25903 PyThreadState* __tstate = wxPyBeginAllowThreads();
25904 (arg1)->SetCurrentFocus(arg2);
25905 wxPyEndAllowThreads(__tstate);
25906 if (PyErr_Occurred()) SWIG_fail;
25907 }
25908 resultobj = SWIG_Py_Void();
25909 return resultobj;
25910 fail:
25911 return NULL;
25912 }
25913
25914
25915 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25916 PyObject *obj;
25917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25918 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25919 return SWIG_Py_Void();
25920 }
25921
25922 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25923 return SWIG_Python_InitShadowInstance(args);
25924 }
25925
25926 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25927 PyObject *resultobj = 0;
25928 wxWindow *arg1 = (wxWindow *) NULL ;
25929 wxWindowCreateEvent *result = 0 ;
25930 void *argp1 = 0 ;
25931 int res1 = 0 ;
25932 PyObject * obj0 = 0 ;
25933 char * kwnames[] = {
25934 (char *) "win", NULL
25935 };
25936
25937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25938 if (obj0) {
25939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25940 if (!SWIG_IsOK(res1)) {
25941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25942 }
25943 arg1 = reinterpret_cast< wxWindow * >(argp1);
25944 }
25945 {
25946 PyThreadState* __tstate = wxPyBeginAllowThreads();
25947 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25948 wxPyEndAllowThreads(__tstate);
25949 if (PyErr_Occurred()) SWIG_fail;
25950 }
25951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25959 PyObject *resultobj = 0;
25960 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25961 wxWindow *result = 0 ;
25962 void *argp1 = 0 ;
25963 int res1 = 0 ;
25964 PyObject *swig_obj[1] ;
25965
25966 if (!args) SWIG_fail;
25967 swig_obj[0] = args;
25968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25969 if (!SWIG_IsOK(res1)) {
25970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25971 }
25972 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 {
25980 resultobj = wxPyMake_wxObject(result, (bool)0);
25981 }
25982 return resultobj;
25983 fail:
25984 return NULL;
25985 }
25986
25987
25988 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25989 PyObject *obj;
25990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25991 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25992 return SWIG_Py_Void();
25993 }
25994
25995 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25996 return SWIG_Python_InitShadowInstance(args);
25997 }
25998
25999 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj = 0;
26001 wxWindow *arg1 = (wxWindow *) NULL ;
26002 wxWindowDestroyEvent *result = 0 ;
26003 void *argp1 = 0 ;
26004 int res1 = 0 ;
26005 PyObject * obj0 = 0 ;
26006 char * kwnames[] = {
26007 (char *) "win", NULL
26008 };
26009
26010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26011 if (obj0) {
26012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26013 if (!SWIG_IsOK(res1)) {
26014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26015 }
26016 arg1 = reinterpret_cast< wxWindow * >(argp1);
26017 }
26018 {
26019 PyThreadState* __tstate = wxPyBeginAllowThreads();
26020 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26021 wxPyEndAllowThreads(__tstate);
26022 if (PyErr_Occurred()) SWIG_fail;
26023 }
26024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26025 return resultobj;
26026 fail:
26027 return NULL;
26028 }
26029
26030
26031 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26032 PyObject *resultobj = 0;
26033 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26034 wxWindow *result = 0 ;
26035 void *argp1 = 0 ;
26036 int res1 = 0 ;
26037 PyObject *swig_obj[1] ;
26038
26039 if (!args) SWIG_fail;
26040 swig_obj[0] = args;
26041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26044 }
26045 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 {
26053 resultobj = wxPyMake_wxObject(result, (bool)0);
26054 }
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26062 PyObject *obj;
26063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26064 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26065 return SWIG_Py_Void();
26066 }
26067
26068 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26069 return SWIG_Python_InitShadowInstance(args);
26070 }
26071
26072 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26073 PyObject *resultobj = 0;
26074 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26075 int arg2 = (int) 0 ;
26076 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26077 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26078 wxContextMenuEvent *result = 0 ;
26079 int val1 ;
26080 int ecode1 = 0 ;
26081 int val2 ;
26082 int ecode2 = 0 ;
26083 wxPoint temp3 ;
26084 PyObject * obj0 = 0 ;
26085 PyObject * obj1 = 0 ;
26086 PyObject * obj2 = 0 ;
26087 char * kwnames[] = {
26088 (char *) "type",(char *) "winid",(char *) "pt", NULL
26089 };
26090
26091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26092 if (obj0) {
26093 ecode1 = SWIG_AsVal_int(obj0, &val1);
26094 if (!SWIG_IsOK(ecode1)) {
26095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26096 }
26097 arg1 = static_cast< wxEventType >(val1);
26098 }
26099 if (obj1) {
26100 ecode2 = SWIG_AsVal_int(obj1, &val2);
26101 if (!SWIG_IsOK(ecode2)) {
26102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26103 }
26104 arg2 = static_cast< int >(val2);
26105 }
26106 if (obj2) {
26107 {
26108 arg3 = &temp3;
26109 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26110 }
26111 }
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26126 PyObject *resultobj = 0;
26127 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26128 wxPoint *result = 0 ;
26129 void *argp1 = 0 ;
26130 int res1 = 0 ;
26131 PyObject *swig_obj[1] ;
26132
26133 if (!args) SWIG_fail;
26134 swig_obj[0] = args;
26135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26136 if (!SWIG_IsOK(res1)) {
26137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26138 }
26139 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 {
26143 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26144 result = (wxPoint *) &_result_ref;
26145 }
26146 wxPyEndAllowThreads(__tstate);
26147 if (PyErr_Occurred()) SWIG_fail;
26148 }
26149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26150 return resultobj;
26151 fail:
26152 return NULL;
26153 }
26154
26155
26156 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26157 PyObject *resultobj = 0;
26158 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26159 wxPoint *arg2 = 0 ;
26160 void *argp1 = 0 ;
26161 int res1 = 0 ;
26162 wxPoint temp2 ;
26163 PyObject * obj0 = 0 ;
26164 PyObject * obj1 = 0 ;
26165 char * kwnames[] = {
26166 (char *) "self",(char *) "pos", NULL
26167 };
26168
26169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26171 if (!SWIG_IsOK(res1)) {
26172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26173 }
26174 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26175 {
26176 arg2 = &temp2;
26177 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26178 }
26179 {
26180 PyThreadState* __tstate = wxPyBeginAllowThreads();
26181 (arg1)->SetPosition((wxPoint const &)*arg2);
26182 wxPyEndAllowThreads(__tstate);
26183 if (PyErr_Occurred()) SWIG_fail;
26184 }
26185 resultobj = SWIG_Py_Void();
26186 return resultobj;
26187 fail:
26188 return NULL;
26189 }
26190
26191
26192 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26193 PyObject *obj;
26194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26195 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26196 return SWIG_Py_Void();
26197 }
26198
26199 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26200 return SWIG_Python_InitShadowInstance(args);
26201 }
26202
26203 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26204 PyObject *resultobj = 0;
26205 wxIdleEvent *result = 0 ;
26206
26207 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 result = (wxIdleEvent *)new wxIdleEvent();
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26222 PyObject *resultobj = 0;
26223 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26224 bool arg2 = (bool) true ;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 bool val2 ;
26228 int ecode2 = 0 ;
26229 PyObject * obj0 = 0 ;
26230 PyObject * obj1 = 0 ;
26231 char * kwnames[] = {
26232 (char *) "self",(char *) "needMore", NULL
26233 };
26234
26235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26237 if (!SWIG_IsOK(res1)) {
26238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26239 }
26240 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26241 if (obj1) {
26242 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26243 if (!SWIG_IsOK(ecode2)) {
26244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26245 }
26246 arg2 = static_cast< bool >(val2);
26247 }
26248 {
26249 PyThreadState* __tstate = wxPyBeginAllowThreads();
26250 (arg1)->RequestMore(arg2);
26251 wxPyEndAllowThreads(__tstate);
26252 if (PyErr_Occurred()) SWIG_fail;
26253 }
26254 resultobj = SWIG_Py_Void();
26255 return resultobj;
26256 fail:
26257 return NULL;
26258 }
26259
26260
26261 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26262 PyObject *resultobj = 0;
26263 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26264 bool result;
26265 void *argp1 = 0 ;
26266 int res1 = 0 ;
26267 PyObject *swig_obj[1] ;
26268
26269 if (!args) SWIG_fail;
26270 swig_obj[0] = args;
26271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26272 if (!SWIG_IsOK(res1)) {
26273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26274 }
26275 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 {
26283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26284 }
26285 return resultobj;
26286 fail:
26287 return NULL;
26288 }
26289
26290
26291 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26292 PyObject *resultobj = 0;
26293 wxIdleMode arg1 ;
26294 int val1 ;
26295 int ecode1 = 0 ;
26296 PyObject * obj0 = 0 ;
26297 char * kwnames[] = {
26298 (char *) "mode", NULL
26299 };
26300
26301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26302 ecode1 = SWIG_AsVal_int(obj0, &val1);
26303 if (!SWIG_IsOK(ecode1)) {
26304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26305 }
26306 arg1 = static_cast< wxIdleMode >(val1);
26307 {
26308 PyThreadState* __tstate = wxPyBeginAllowThreads();
26309 wxIdleEvent::SetMode(arg1);
26310 wxPyEndAllowThreads(__tstate);
26311 if (PyErr_Occurred()) SWIG_fail;
26312 }
26313 resultobj = SWIG_Py_Void();
26314 return resultobj;
26315 fail:
26316 return NULL;
26317 }
26318
26319
26320 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26321 PyObject *resultobj = 0;
26322 wxIdleMode result;
26323
26324 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26325 {
26326 PyThreadState* __tstate = wxPyBeginAllowThreads();
26327 result = (wxIdleMode)wxIdleEvent::GetMode();
26328 wxPyEndAllowThreads(__tstate);
26329 if (PyErr_Occurred()) SWIG_fail;
26330 }
26331 resultobj = SWIG_From_int(static_cast< int >(result));
26332 return resultobj;
26333 fail:
26334 return NULL;
26335 }
26336
26337
26338 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26339 PyObject *resultobj = 0;
26340 wxWindow *arg1 = (wxWindow *) 0 ;
26341 bool result;
26342 void *argp1 = 0 ;
26343 int res1 = 0 ;
26344 PyObject * obj0 = 0 ;
26345 char * kwnames[] = {
26346 (char *) "win", NULL
26347 };
26348
26349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26351 if (!SWIG_IsOK(res1)) {
26352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26353 }
26354 arg1 = reinterpret_cast< wxWindow * >(argp1);
26355 {
26356 PyThreadState* __tstate = wxPyBeginAllowThreads();
26357 result = (bool)wxIdleEvent::CanSend(arg1);
26358 wxPyEndAllowThreads(__tstate);
26359 if (PyErr_Occurred()) SWIG_fail;
26360 }
26361 {
26362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26363 }
26364 return resultobj;
26365 fail:
26366 return NULL;
26367 }
26368
26369
26370 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26371 PyObject *obj;
26372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26373 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26374 return SWIG_Py_Void();
26375 }
26376
26377 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26378 return SWIG_Python_InitShadowInstance(args);
26379 }
26380
26381 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26382 PyObject *resultobj = 0;
26383 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26384 int arg2 = (int) 0 ;
26385 wxClipboardTextEvent *result = 0 ;
26386 int val1 ;
26387 int ecode1 = 0 ;
26388 int val2 ;
26389 int ecode2 = 0 ;
26390 PyObject * obj0 = 0 ;
26391 PyObject * obj1 = 0 ;
26392 char * kwnames[] = {
26393 (char *) "type",(char *) "winid", NULL
26394 };
26395
26396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26397 if (obj0) {
26398 ecode1 = SWIG_AsVal_int(obj0, &val1);
26399 if (!SWIG_IsOK(ecode1)) {
26400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26401 }
26402 arg1 = static_cast< wxEventType >(val1);
26403 }
26404 if (obj1) {
26405 ecode2 = SWIG_AsVal_int(obj1, &val2);
26406 if (!SWIG_IsOK(ecode2)) {
26407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26408 }
26409 arg2 = static_cast< int >(val2);
26410 }
26411 {
26412 PyThreadState* __tstate = wxPyBeginAllowThreads();
26413 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26414 wxPyEndAllowThreads(__tstate);
26415 if (PyErr_Occurred()) SWIG_fail;
26416 }
26417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26418 return resultobj;
26419 fail:
26420 return NULL;
26421 }
26422
26423
26424 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26425 PyObject *obj;
26426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26427 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26428 return SWIG_Py_Void();
26429 }
26430
26431 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26432 return SWIG_Python_InitShadowInstance(args);
26433 }
26434
26435 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26436 PyObject *resultobj = 0;
26437 int arg1 = (int) 0 ;
26438 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26439 wxPyEvent *result = 0 ;
26440 int val1 ;
26441 int ecode1 = 0 ;
26442 int val2 ;
26443 int ecode2 = 0 ;
26444 PyObject * obj0 = 0 ;
26445 PyObject * obj1 = 0 ;
26446 char * kwnames[] = {
26447 (char *) "winid",(char *) "eventType", NULL
26448 };
26449
26450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26451 if (obj0) {
26452 ecode1 = SWIG_AsVal_int(obj0, &val1);
26453 if (!SWIG_IsOK(ecode1)) {
26454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26455 }
26456 arg1 = static_cast< int >(val1);
26457 }
26458 if (obj1) {
26459 ecode2 = SWIG_AsVal_int(obj1, &val2);
26460 if (!SWIG_IsOK(ecode2)) {
26461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26462 }
26463 arg2 = static_cast< wxEventType >(val2);
26464 }
26465 {
26466 PyThreadState* __tstate = wxPyBeginAllowThreads();
26467 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26472 return resultobj;
26473 fail:
26474 return NULL;
26475 }
26476
26477
26478 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26479 PyObject *resultobj = 0;
26480 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26481 void *argp1 = 0 ;
26482 int res1 = 0 ;
26483 PyObject *swig_obj[1] ;
26484
26485 if (!args) SWIG_fail;
26486 swig_obj[0] = args;
26487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26488 if (!SWIG_IsOK(res1)) {
26489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26490 }
26491 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26492 {
26493 PyThreadState* __tstate = wxPyBeginAllowThreads();
26494 delete arg1;
26495
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 resultobj = SWIG_Py_Void();
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26507 PyObject *resultobj = 0;
26508 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26509 PyObject *arg2 = (PyObject *) 0 ;
26510 void *argp1 = 0 ;
26511 int res1 = 0 ;
26512 PyObject * obj0 = 0 ;
26513 PyObject * obj1 = 0 ;
26514 char * kwnames[] = {
26515 (char *) "self",(char *) "self", NULL
26516 };
26517
26518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26520 if (!SWIG_IsOK(res1)) {
26521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26522 }
26523 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26524 arg2 = obj1;
26525 {
26526 PyThreadState* __tstate = wxPyBeginAllowThreads();
26527 (arg1)->SetSelf(arg2);
26528 wxPyEndAllowThreads(__tstate);
26529 if (PyErr_Occurred()) SWIG_fail;
26530 }
26531 resultobj = SWIG_Py_Void();
26532 return resultobj;
26533 fail:
26534 return NULL;
26535 }
26536
26537
26538 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26539 PyObject *resultobj = 0;
26540 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26541 PyObject *result = 0 ;
26542 void *argp1 = 0 ;
26543 int res1 = 0 ;
26544 PyObject *swig_obj[1] ;
26545
26546 if (!args) SWIG_fail;
26547 swig_obj[0] = args;
26548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26549 if (!SWIG_IsOK(res1)) {
26550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26551 }
26552 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 result = (PyObject *)(arg1)->GetSelf();
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 resultobj = result;
26560 return resultobj;
26561 fail:
26562 return NULL;
26563 }
26564
26565
26566 SWIGINTERN PyObject *PyEvent_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_wxPyEvent, SWIG_NewClientData(obj));
26570 return SWIG_Py_Void();
26571 }
26572
26573 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26574 return SWIG_Python_InitShadowInstance(args);
26575 }
26576
26577 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26578 PyObject *resultobj = 0;
26579 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26580 int arg2 = (int) 0 ;
26581 wxPyCommandEvent *result = 0 ;
26582 int val1 ;
26583 int ecode1 = 0 ;
26584 int val2 ;
26585 int ecode2 = 0 ;
26586 PyObject * obj0 = 0 ;
26587 PyObject * obj1 = 0 ;
26588 char * kwnames[] = {
26589 (char *) "eventType",(char *) "id", NULL
26590 };
26591
26592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26593 if (obj0) {
26594 ecode1 = SWIG_AsVal_int(obj0, &val1);
26595 if (!SWIG_IsOK(ecode1)) {
26596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26597 }
26598 arg1 = static_cast< wxEventType >(val1);
26599 }
26600 if (obj1) {
26601 ecode2 = SWIG_AsVal_int(obj1, &val2);
26602 if (!SWIG_IsOK(ecode2)) {
26603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26604 }
26605 arg2 = static_cast< int >(val2);
26606 }
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26614 return resultobj;
26615 fail:
26616 return NULL;
26617 }
26618
26619
26620 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26621 PyObject *resultobj = 0;
26622 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26623 void *argp1 = 0 ;
26624 int res1 = 0 ;
26625 PyObject *swig_obj[1] ;
26626
26627 if (!args) SWIG_fail;
26628 swig_obj[0] = args;
26629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26630 if (!SWIG_IsOK(res1)) {
26631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26632 }
26633 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26634 {
26635 PyThreadState* __tstate = wxPyBeginAllowThreads();
26636 delete arg1;
26637
26638 wxPyEndAllowThreads(__tstate);
26639 if (PyErr_Occurred()) SWIG_fail;
26640 }
26641 resultobj = SWIG_Py_Void();
26642 return resultobj;
26643 fail:
26644 return NULL;
26645 }
26646
26647
26648 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26649 PyObject *resultobj = 0;
26650 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26651 PyObject *arg2 = (PyObject *) 0 ;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 PyObject * obj0 = 0 ;
26655 PyObject * obj1 = 0 ;
26656 char * kwnames[] = {
26657 (char *) "self",(char *) "self", NULL
26658 };
26659
26660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26662 if (!SWIG_IsOK(res1)) {
26663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26664 }
26665 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26666 arg2 = obj1;
26667 {
26668 PyThreadState* __tstate = wxPyBeginAllowThreads();
26669 (arg1)->SetSelf(arg2);
26670 wxPyEndAllowThreads(__tstate);
26671 if (PyErr_Occurred()) SWIG_fail;
26672 }
26673 resultobj = SWIG_Py_Void();
26674 return resultobj;
26675 fail:
26676 return NULL;
26677 }
26678
26679
26680 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26681 PyObject *resultobj = 0;
26682 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26683 PyObject *result = 0 ;
26684 void *argp1 = 0 ;
26685 int res1 = 0 ;
26686 PyObject *swig_obj[1] ;
26687
26688 if (!args) SWIG_fail;
26689 swig_obj[0] = args;
26690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26691 if (!SWIG_IsOK(res1)) {
26692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26693 }
26694 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26695 {
26696 PyThreadState* __tstate = wxPyBeginAllowThreads();
26697 result = (PyObject *)(arg1)->GetSelf();
26698 wxPyEndAllowThreads(__tstate);
26699 if (PyErr_Occurred()) SWIG_fail;
26700 }
26701 resultobj = result;
26702 return resultobj;
26703 fail:
26704 return NULL;
26705 }
26706
26707
26708 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26709 PyObject *obj;
26710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26711 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26712 return SWIG_Py_Void();
26713 }
26714
26715 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26716 return SWIG_Python_InitShadowInstance(args);
26717 }
26718
26719 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26720 PyObject *resultobj = 0;
26721 wxWindow *arg1 = (wxWindow *) 0 ;
26722 wxDateTime *arg2 = 0 ;
26723 wxEventType arg3 ;
26724 wxDateEvent *result = 0 ;
26725 void *argp1 = 0 ;
26726 int res1 = 0 ;
26727 void *argp2 = 0 ;
26728 int res2 = 0 ;
26729 int val3 ;
26730 int ecode3 = 0 ;
26731 PyObject * obj0 = 0 ;
26732 PyObject * obj1 = 0 ;
26733 PyObject * obj2 = 0 ;
26734 char * kwnames[] = {
26735 (char *) "win",(char *) "dt",(char *) "type", NULL
26736 };
26737
26738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26740 if (!SWIG_IsOK(res1)) {
26741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26742 }
26743 arg1 = reinterpret_cast< wxWindow * >(argp1);
26744 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26745 if (!SWIG_IsOK(res2)) {
26746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26747 }
26748 if (!argp2) {
26749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26750 }
26751 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26752 ecode3 = SWIG_AsVal_int(obj2, &val3);
26753 if (!SWIG_IsOK(ecode3)) {
26754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26755 }
26756 arg3 = static_cast< wxEventType >(val3);
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26771 PyObject *resultobj = 0;
26772 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26773 wxDateTime *result = 0 ;
26774 void *argp1 = 0 ;
26775 int res1 = 0 ;
26776 PyObject *swig_obj[1] ;
26777
26778 if (!args) SWIG_fail;
26779 swig_obj[0] = args;
26780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26781 if (!SWIG_IsOK(res1)) {
26782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26783 }
26784 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 {
26788 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26789 result = (wxDateTime *) &_result_ref;
26790 }
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26795 return resultobj;
26796 fail:
26797 return NULL;
26798 }
26799
26800
26801 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26802 PyObject *resultobj = 0;
26803 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26804 wxDateTime *arg2 = 0 ;
26805 void *argp1 = 0 ;
26806 int res1 = 0 ;
26807 void *argp2 = 0 ;
26808 int res2 = 0 ;
26809 PyObject * obj0 = 0 ;
26810 PyObject * obj1 = 0 ;
26811 char * kwnames[] = {
26812 (char *) "self",(char *) "date", NULL
26813 };
26814
26815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26817 if (!SWIG_IsOK(res1)) {
26818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26819 }
26820 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26821 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26822 if (!SWIG_IsOK(res2)) {
26823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26824 }
26825 if (!argp2) {
26826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26827 }
26828 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 (arg1)->SetDate((wxDateTime const &)*arg2);
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 resultobj = SWIG_Py_Void();
26836 return resultobj;
26837 fail:
26838 return NULL;
26839 }
26840
26841
26842 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26843 PyObject *obj;
26844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26845 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26846 return SWIG_Py_Void();
26847 }
26848
26849 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26850 return SWIG_Python_InitShadowInstance(args);
26851 }
26852
26853 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26854 PyObject *resultobj = 0;
26855 wxPyApp *result = 0 ;
26856
26857 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 result = (wxPyApp *)new_wxPyApp();
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 PyObject *resultobj = 0;
26873 wxPyApp *arg1 = (wxPyApp *) 0 ;
26874 void *argp1 = 0 ;
26875 int res1 = 0 ;
26876 PyObject *swig_obj[1] ;
26877
26878 if (!args) SWIG_fail;
26879 swig_obj[0] = args;
26880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26881 if (!SWIG_IsOK(res1)) {
26882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26883 }
26884 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26885 {
26886 PyThreadState* __tstate = wxPyBeginAllowThreads();
26887 delete arg1;
26888
26889 wxPyEndAllowThreads(__tstate);
26890 if (PyErr_Occurred()) SWIG_fail;
26891 }
26892 resultobj = SWIG_Py_Void();
26893 return resultobj;
26894 fail:
26895 return NULL;
26896 }
26897
26898
26899 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26900 PyObject *resultobj = 0;
26901 wxPyApp *arg1 = (wxPyApp *) 0 ;
26902 PyObject *arg2 = (PyObject *) 0 ;
26903 PyObject *arg3 = (PyObject *) 0 ;
26904 bool arg4 ;
26905 void *argp1 = 0 ;
26906 int res1 = 0 ;
26907 bool val4 ;
26908 int ecode4 = 0 ;
26909 PyObject * obj0 = 0 ;
26910 PyObject * obj1 = 0 ;
26911 PyObject * obj2 = 0 ;
26912 PyObject * obj3 = 0 ;
26913 char * kwnames[] = {
26914 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26915 };
26916
26917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26919 if (!SWIG_IsOK(res1)) {
26920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26921 }
26922 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26923 arg2 = obj1;
26924 arg3 = obj2;
26925 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26926 if (!SWIG_IsOK(ecode4)) {
26927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26928 }
26929 arg4 = static_cast< bool >(val4);
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_Py_Void();
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26944 PyObject *resultobj = 0;
26945 wxPyApp *arg1 = (wxPyApp *) 0 ;
26946 wxString result;
26947 void *argp1 = 0 ;
26948 int res1 = 0 ;
26949 PyObject *swig_obj[1] ;
26950
26951 if (!args) SWIG_fail;
26952 swig_obj[0] = args;
26953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26954 if (!SWIG_IsOK(res1)) {
26955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26956 }
26957 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 result = ((wxPyApp const *)arg1)->GetAppName();
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 {
26965 #if wxUSE_UNICODE
26966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26967 #else
26968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26969 #endif
26970 }
26971 return resultobj;
26972 fail:
26973 return NULL;
26974 }
26975
26976
26977 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26978 PyObject *resultobj = 0;
26979 wxPyApp *arg1 = (wxPyApp *) 0 ;
26980 wxString *arg2 = 0 ;
26981 void *argp1 = 0 ;
26982 int res1 = 0 ;
26983 bool temp2 = false ;
26984 PyObject * obj0 = 0 ;
26985 PyObject * obj1 = 0 ;
26986 char * kwnames[] = {
26987 (char *) "self",(char *) "name", NULL
26988 };
26989
26990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26992 if (!SWIG_IsOK(res1)) {
26993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26994 }
26995 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26996 {
26997 arg2 = wxString_in_helper(obj1);
26998 if (arg2 == NULL) SWIG_fail;
26999 temp2 = true;
27000 }
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 (arg1)->SetAppName((wxString const &)*arg2);
27004 wxPyEndAllowThreads(__tstate);
27005 if (PyErr_Occurred()) SWIG_fail;
27006 }
27007 resultobj = SWIG_Py_Void();
27008 {
27009 if (temp2)
27010 delete arg2;
27011 }
27012 return resultobj;
27013 fail:
27014 {
27015 if (temp2)
27016 delete arg2;
27017 }
27018 return NULL;
27019 }
27020
27021
27022 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27023 PyObject *resultobj = 0;
27024 wxPyApp *arg1 = (wxPyApp *) 0 ;
27025 wxString result;
27026 void *argp1 = 0 ;
27027 int res1 = 0 ;
27028 PyObject *swig_obj[1] ;
27029
27030 if (!args) SWIG_fail;
27031 swig_obj[0] = args;
27032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27033 if (!SWIG_IsOK(res1)) {
27034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27035 }
27036 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27037 {
27038 PyThreadState* __tstate = wxPyBeginAllowThreads();
27039 result = ((wxPyApp const *)arg1)->GetClassName();
27040 wxPyEndAllowThreads(__tstate);
27041 if (PyErr_Occurred()) SWIG_fail;
27042 }
27043 {
27044 #if wxUSE_UNICODE
27045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27046 #else
27047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27048 #endif
27049 }
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj = 0;
27058 wxPyApp *arg1 = (wxPyApp *) 0 ;
27059 wxString *arg2 = 0 ;
27060 void *argp1 = 0 ;
27061 int res1 = 0 ;
27062 bool temp2 = false ;
27063 PyObject * obj0 = 0 ;
27064 PyObject * obj1 = 0 ;
27065 char * kwnames[] = {
27066 (char *) "self",(char *) "name", NULL
27067 };
27068
27069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27071 if (!SWIG_IsOK(res1)) {
27072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27073 }
27074 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27075 {
27076 arg2 = wxString_in_helper(obj1);
27077 if (arg2 == NULL) SWIG_fail;
27078 temp2 = true;
27079 }
27080 {
27081 PyThreadState* __tstate = wxPyBeginAllowThreads();
27082 (arg1)->SetClassName((wxString const &)*arg2);
27083 wxPyEndAllowThreads(__tstate);
27084 if (PyErr_Occurred()) SWIG_fail;
27085 }
27086 resultobj = SWIG_Py_Void();
27087 {
27088 if (temp2)
27089 delete arg2;
27090 }
27091 return resultobj;
27092 fail:
27093 {
27094 if (temp2)
27095 delete arg2;
27096 }
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27102 PyObject *resultobj = 0;
27103 wxPyApp *arg1 = (wxPyApp *) 0 ;
27104 wxString *result = 0 ;
27105 void *argp1 = 0 ;
27106 int res1 = 0 ;
27107 PyObject *swig_obj[1] ;
27108
27109 if (!args) SWIG_fail;
27110 swig_obj[0] = args;
27111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27112 if (!SWIG_IsOK(res1)) {
27113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27114 }
27115 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 {
27119 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27120 result = (wxString *) &_result_ref;
27121 }
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 {
27126 #if wxUSE_UNICODE
27127 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27128 #else
27129 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27130 #endif
27131 }
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27139 PyObject *resultobj = 0;
27140 wxPyApp *arg1 = (wxPyApp *) 0 ;
27141 wxString *arg2 = 0 ;
27142 void *argp1 = 0 ;
27143 int res1 = 0 ;
27144 bool temp2 = false ;
27145 PyObject * obj0 = 0 ;
27146 PyObject * obj1 = 0 ;
27147 char * kwnames[] = {
27148 (char *) "self",(char *) "name", NULL
27149 };
27150
27151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27153 if (!SWIG_IsOK(res1)) {
27154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27155 }
27156 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27157 {
27158 arg2 = wxString_in_helper(obj1);
27159 if (arg2 == NULL) SWIG_fail;
27160 temp2 = true;
27161 }
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 (arg1)->SetVendorName((wxString const &)*arg2);
27165 wxPyEndAllowThreads(__tstate);
27166 if (PyErr_Occurred()) SWIG_fail;
27167 }
27168 resultobj = SWIG_Py_Void();
27169 {
27170 if (temp2)
27171 delete arg2;
27172 }
27173 return resultobj;
27174 fail:
27175 {
27176 if (temp2)
27177 delete arg2;
27178 }
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27184 PyObject *resultobj = 0;
27185 wxPyApp *arg1 = (wxPyApp *) 0 ;
27186 wxAppTraits *result = 0 ;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 PyObject *swig_obj[1] ;
27190
27191 if (!args) SWIG_fail;
27192 swig_obj[0] = args;
27193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27194 if (!SWIG_IsOK(res1)) {
27195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27196 }
27197 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 result = (wxAppTraits *)(arg1)->GetTraits();
27201 wxPyEndAllowThreads(__tstate);
27202 if (PyErr_Occurred()) SWIG_fail;
27203 }
27204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27212 PyObject *resultobj = 0;
27213 wxPyApp *arg1 = (wxPyApp *) 0 ;
27214 void *argp1 = 0 ;
27215 int res1 = 0 ;
27216 PyObject *swig_obj[1] ;
27217
27218 if (!args) SWIG_fail;
27219 swig_obj[0] = args;
27220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27221 if (!SWIG_IsOK(res1)) {
27222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27223 }
27224 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27225 {
27226 PyThreadState* __tstate = wxPyBeginAllowThreads();
27227 (arg1)->ProcessPendingEvents();
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 resultobj = SWIG_Py_Void();
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27239 PyObject *resultobj = 0;
27240 wxPyApp *arg1 = (wxPyApp *) 0 ;
27241 bool arg2 = (bool) false ;
27242 bool result;
27243 void *argp1 = 0 ;
27244 int res1 = 0 ;
27245 bool val2 ;
27246 int ecode2 = 0 ;
27247 PyObject * obj0 = 0 ;
27248 PyObject * obj1 = 0 ;
27249 char * kwnames[] = {
27250 (char *) "self",(char *) "onlyIfNeeded", NULL
27251 };
27252
27253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27255 if (!SWIG_IsOK(res1)) {
27256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27257 }
27258 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27259 if (obj1) {
27260 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27261 if (!SWIG_IsOK(ecode2)) {
27262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27263 }
27264 arg2 = static_cast< bool >(val2);
27265 }
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 result = (bool)(arg1)->Yield(arg2);
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27274 }
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27282 PyObject *resultobj = 0;
27283 wxPyApp *arg1 = (wxPyApp *) 0 ;
27284 void *argp1 = 0 ;
27285 int res1 = 0 ;
27286 PyObject *swig_obj[1] ;
27287
27288 if (!args) SWIG_fail;
27289 swig_obj[0] = args;
27290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27291 if (!SWIG_IsOK(res1)) {
27292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27293 }
27294 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 (arg1)->WakeUpIdle();
27298 wxPyEndAllowThreads(__tstate);
27299 if (PyErr_Occurred()) SWIG_fail;
27300 }
27301 resultobj = SWIG_Py_Void();
27302 return resultobj;
27303 fail:
27304 return NULL;
27305 }
27306
27307
27308 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27309 PyObject *resultobj = 0;
27310 bool result;
27311
27312 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27313 {
27314 PyThreadState* __tstate = wxPyBeginAllowThreads();
27315 result = (bool)wxPyApp::IsMainLoopRunning();
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 {
27320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27321 }
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27329 PyObject *resultobj = 0;
27330 wxPyApp *arg1 = (wxPyApp *) 0 ;
27331 int result;
27332 void *argp1 = 0 ;
27333 int res1 = 0 ;
27334 PyObject *swig_obj[1] ;
27335
27336 if (!args) SWIG_fail;
27337 swig_obj[0] = args;
27338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27339 if (!SWIG_IsOK(res1)) {
27340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27341 }
27342 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 result = (int)(arg1)->MainLoop();
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 resultobj = SWIG_From_int(static_cast< int >(result));
27350 return resultobj;
27351 fail:
27352 return NULL;
27353 }
27354
27355
27356 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27357 PyObject *resultobj = 0;
27358 wxPyApp *arg1 = (wxPyApp *) 0 ;
27359 void *argp1 = 0 ;
27360 int res1 = 0 ;
27361 PyObject *swig_obj[1] ;
27362
27363 if (!args) SWIG_fail;
27364 swig_obj[0] = args;
27365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27366 if (!SWIG_IsOK(res1)) {
27367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27368 }
27369 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27370 {
27371 PyThreadState* __tstate = wxPyBeginAllowThreads();
27372 (arg1)->Exit();
27373 wxPyEndAllowThreads(__tstate);
27374 if (PyErr_Occurred()) SWIG_fail;
27375 }
27376 resultobj = SWIG_Py_Void();
27377 return resultobj;
27378 fail:
27379 return NULL;
27380 }
27381
27382
27383 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27384 PyObject *resultobj = 0;
27385 wxPyApp *arg1 = (wxPyApp *) 0 ;
27386 void *argp1 = 0 ;
27387 int res1 = 0 ;
27388 PyObject *swig_obj[1] ;
27389
27390 if (!args) SWIG_fail;
27391 swig_obj[0] = args;
27392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27393 if (!SWIG_IsOK(res1)) {
27394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27395 }
27396 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 (arg1)->ExitMainLoop();
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 resultobj = SWIG_Py_Void();
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27411 PyObject *resultobj = 0;
27412 wxPyApp *arg1 = (wxPyApp *) 0 ;
27413 bool result;
27414 void *argp1 = 0 ;
27415 int res1 = 0 ;
27416 PyObject *swig_obj[1] ;
27417
27418 if (!args) SWIG_fail;
27419 swig_obj[0] = args;
27420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27421 if (!SWIG_IsOK(res1)) {
27422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27423 }
27424 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = (bool)(arg1)->Pending();
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 {
27432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27433 }
27434 return resultobj;
27435 fail:
27436 return NULL;
27437 }
27438
27439
27440 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27441 PyObject *resultobj = 0;
27442 wxPyApp *arg1 = (wxPyApp *) 0 ;
27443 bool result;
27444 void *argp1 = 0 ;
27445 int res1 = 0 ;
27446 PyObject *swig_obj[1] ;
27447
27448 if (!args) SWIG_fail;
27449 swig_obj[0] = args;
27450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27451 if (!SWIG_IsOK(res1)) {
27452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27453 }
27454 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27455 {
27456 PyThreadState* __tstate = wxPyBeginAllowThreads();
27457 result = (bool)(arg1)->Dispatch();
27458 wxPyEndAllowThreads(__tstate);
27459 if (PyErr_Occurred()) SWIG_fail;
27460 }
27461 {
27462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27463 }
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27471 PyObject *resultobj = 0;
27472 wxPyApp *arg1 = (wxPyApp *) 0 ;
27473 bool result;
27474 void *argp1 = 0 ;
27475 int res1 = 0 ;
27476 PyObject *swig_obj[1] ;
27477
27478 if (!args) SWIG_fail;
27479 swig_obj[0] = args;
27480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27481 if (!SWIG_IsOK(res1)) {
27482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27483 }
27484 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (bool)(arg1)->ProcessIdle();
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 {
27492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27493 }
27494 return resultobj;
27495 fail:
27496 return NULL;
27497 }
27498
27499
27500 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27501 PyObject *resultobj = 0;
27502 wxPyApp *arg1 = (wxPyApp *) 0 ;
27503 wxWindow *arg2 = (wxWindow *) 0 ;
27504 wxIdleEvent *arg3 = 0 ;
27505 bool result;
27506 void *argp1 = 0 ;
27507 int res1 = 0 ;
27508 void *argp2 = 0 ;
27509 int res2 = 0 ;
27510 void *argp3 = 0 ;
27511 int res3 = 0 ;
27512 PyObject * obj0 = 0 ;
27513 PyObject * obj1 = 0 ;
27514 PyObject * obj2 = 0 ;
27515 char * kwnames[] = {
27516 (char *) "self",(char *) "win",(char *) "event", NULL
27517 };
27518
27519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27521 if (!SWIG_IsOK(res1)) {
27522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27523 }
27524 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27525 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27526 if (!SWIG_IsOK(res2)) {
27527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27528 }
27529 arg2 = reinterpret_cast< wxWindow * >(argp2);
27530 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27531 if (!SWIG_IsOK(res3)) {
27532 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27533 }
27534 if (!argp3) {
27535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27536 }
27537 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27538 {
27539 PyThreadState* __tstate = wxPyBeginAllowThreads();
27540 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 {
27545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27546 }
27547 return resultobj;
27548 fail:
27549 return NULL;
27550 }
27551
27552
27553 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27554 PyObject *resultobj = 0;
27555 wxPyApp *arg1 = (wxPyApp *) 0 ;
27556 bool result;
27557 void *argp1 = 0 ;
27558 int res1 = 0 ;
27559 PyObject *swig_obj[1] ;
27560
27561 if (!args) SWIG_fail;
27562 swig_obj[0] = args;
27563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27564 if (!SWIG_IsOK(res1)) {
27565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27566 }
27567 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27568 {
27569 PyThreadState* __tstate = wxPyBeginAllowThreads();
27570 result = (bool)((wxPyApp const *)arg1)->IsActive();
27571 wxPyEndAllowThreads(__tstate);
27572 if (PyErr_Occurred()) SWIG_fail;
27573 }
27574 {
27575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27576 }
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27584 PyObject *resultobj = 0;
27585 wxPyApp *arg1 = (wxPyApp *) 0 ;
27586 wxWindow *arg2 = (wxWindow *) 0 ;
27587 void *argp1 = 0 ;
27588 int res1 = 0 ;
27589 void *argp2 = 0 ;
27590 int res2 = 0 ;
27591 PyObject * obj0 = 0 ;
27592 PyObject * obj1 = 0 ;
27593 char * kwnames[] = {
27594 (char *) "self",(char *) "win", NULL
27595 };
27596
27597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27599 if (!SWIG_IsOK(res1)) {
27600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27601 }
27602 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27604 if (!SWIG_IsOK(res2)) {
27605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27606 }
27607 arg2 = reinterpret_cast< wxWindow * >(argp2);
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 (arg1)->SetTopWindow(arg2);
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 resultobj = SWIG_Py_Void();
27615 return resultobj;
27616 fail:
27617 return NULL;
27618 }
27619
27620
27621 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27622 PyObject *resultobj = 0;
27623 wxPyApp *arg1 = (wxPyApp *) 0 ;
27624 wxWindow *result = 0 ;
27625 void *argp1 = 0 ;
27626 int res1 = 0 ;
27627 PyObject *swig_obj[1] ;
27628
27629 if (!args) SWIG_fail;
27630 swig_obj[0] = args;
27631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27632 if (!SWIG_IsOK(res1)) {
27633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27634 }
27635 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = wxPyMake_wxObject(result, (bool)0);
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj = 0;
27653 wxPyApp *arg1 = (wxPyApp *) 0 ;
27654 bool arg2 ;
27655 void *argp1 = 0 ;
27656 int res1 = 0 ;
27657 bool val2 ;
27658 int ecode2 = 0 ;
27659 PyObject * obj0 = 0 ;
27660 PyObject * obj1 = 0 ;
27661 char * kwnames[] = {
27662 (char *) "self",(char *) "flag", NULL
27663 };
27664
27665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27667 if (!SWIG_IsOK(res1)) {
27668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27669 }
27670 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27671 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27672 if (!SWIG_IsOK(ecode2)) {
27673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27674 }
27675 arg2 = static_cast< bool >(val2);
27676 {
27677 PyThreadState* __tstate = wxPyBeginAllowThreads();
27678 (arg1)->SetExitOnFrameDelete(arg2);
27679 wxPyEndAllowThreads(__tstate);
27680 if (PyErr_Occurred()) SWIG_fail;
27681 }
27682 resultobj = SWIG_Py_Void();
27683 return resultobj;
27684 fail:
27685 return NULL;
27686 }
27687
27688
27689 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27690 PyObject *resultobj = 0;
27691 wxPyApp *arg1 = (wxPyApp *) 0 ;
27692 bool result;
27693 void *argp1 = 0 ;
27694 int res1 = 0 ;
27695 PyObject *swig_obj[1] ;
27696
27697 if (!args) SWIG_fail;
27698 swig_obj[0] = args;
27699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27700 if (!SWIG_IsOK(res1)) {
27701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27702 }
27703 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27704 {
27705 PyThreadState* __tstate = wxPyBeginAllowThreads();
27706 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27707 wxPyEndAllowThreads(__tstate);
27708 if (PyErr_Occurred()) SWIG_fail;
27709 }
27710 {
27711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27712 }
27713 return resultobj;
27714 fail:
27715 return NULL;
27716 }
27717
27718
27719 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27720 PyObject *resultobj = 0;
27721 wxPyApp *arg1 = (wxPyApp *) 0 ;
27722 bool arg2 ;
27723 void *argp1 = 0 ;
27724 int res1 = 0 ;
27725 bool val2 ;
27726 int ecode2 = 0 ;
27727 PyObject * obj0 = 0 ;
27728 PyObject * obj1 = 0 ;
27729 char * kwnames[] = {
27730 (char *) "self",(char *) "flag", NULL
27731 };
27732
27733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27735 if (!SWIG_IsOK(res1)) {
27736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27737 }
27738 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27739 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27740 if (!SWIG_IsOK(ecode2)) {
27741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27742 }
27743 arg2 = static_cast< bool >(val2);
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 (arg1)->SetUseBestVisual(arg2);
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_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27758 PyObject *resultobj = 0;
27759 wxPyApp *arg1 = (wxPyApp *) 0 ;
27760 bool 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_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27770 }
27771 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 {
27779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27780 }
27781 return resultobj;
27782 fail:
27783 return NULL;
27784 }
27785
27786
27787 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27788 PyObject *resultobj = 0;
27789 wxPyApp *arg1 = (wxPyApp *) 0 ;
27790 int arg2 ;
27791 void *argp1 = 0 ;
27792 int res1 = 0 ;
27793 int val2 ;
27794 int ecode2 = 0 ;
27795 PyObject * obj0 = 0 ;
27796 PyObject * obj1 = 0 ;
27797 char * kwnames[] = {
27798 (char *) "self",(char *) "mode", NULL
27799 };
27800
27801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27803 if (!SWIG_IsOK(res1)) {
27804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27805 }
27806 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27807 ecode2 = SWIG_AsVal_int(obj1, &val2);
27808 if (!SWIG_IsOK(ecode2)) {
27809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27810 }
27811 arg2 = static_cast< int >(val2);
27812 {
27813 PyThreadState* __tstate = wxPyBeginAllowThreads();
27814 (arg1)->SetPrintMode(arg2);
27815 wxPyEndAllowThreads(__tstate);
27816 if (PyErr_Occurred()) SWIG_fail;
27817 }
27818 resultobj = SWIG_Py_Void();
27819 return resultobj;
27820 fail:
27821 return NULL;
27822 }
27823
27824
27825 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27826 PyObject *resultobj = 0;
27827 wxPyApp *arg1 = (wxPyApp *) 0 ;
27828 int result;
27829 void *argp1 = 0 ;
27830 int res1 = 0 ;
27831 PyObject *swig_obj[1] ;
27832
27833 if (!args) SWIG_fail;
27834 swig_obj[0] = args;
27835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27836 if (!SWIG_IsOK(res1)) {
27837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27838 }
27839 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 resultobj = SWIG_From_int(static_cast< int >(result));
27847 return resultobj;
27848 fail:
27849 return NULL;
27850 }
27851
27852
27853 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27854 PyObject *resultobj = 0;
27855 wxPyApp *arg1 = (wxPyApp *) 0 ;
27856 int arg2 ;
27857 void *argp1 = 0 ;
27858 int res1 = 0 ;
27859 int val2 ;
27860 int ecode2 = 0 ;
27861 PyObject * obj0 = 0 ;
27862 PyObject * obj1 = 0 ;
27863 char * kwnames[] = {
27864 (char *) "self",(char *) "mode", NULL
27865 };
27866
27867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27869 if (!SWIG_IsOK(res1)) {
27870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27871 }
27872 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27873 ecode2 = SWIG_AsVal_int(obj1, &val2);
27874 if (!SWIG_IsOK(ecode2)) {
27875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27876 }
27877 arg2 = static_cast< int >(val2);
27878 {
27879 PyThreadState* __tstate = wxPyBeginAllowThreads();
27880 (arg1)->SetAssertMode(arg2);
27881 wxPyEndAllowThreads(__tstate);
27882 if (PyErr_Occurred()) SWIG_fail;
27883 }
27884 resultobj = SWIG_Py_Void();
27885 return resultobj;
27886 fail:
27887 return NULL;
27888 }
27889
27890
27891 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27892 PyObject *resultobj = 0;
27893 wxPyApp *arg1 = (wxPyApp *) 0 ;
27894 int result;
27895 void *argp1 = 0 ;
27896 int res1 = 0 ;
27897 PyObject *swig_obj[1] ;
27898
27899 if (!args) SWIG_fail;
27900 swig_obj[0] = args;
27901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27902 if (!SWIG_IsOK(res1)) {
27903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27904 }
27905 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 result = (int)(arg1)->GetAssertMode();
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 resultobj = SWIG_From_int(static_cast< int >(result));
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27920 PyObject *resultobj = 0;
27921 bool result;
27922
27923 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 {
27931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27932 }
27933 return resultobj;
27934 fail:
27935 return NULL;
27936 }
27937
27938
27939 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27940 PyObject *resultobj = 0;
27941 long result;
27942
27943 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27944 {
27945 PyThreadState* __tstate = wxPyBeginAllowThreads();
27946 result = (long)wxPyApp::GetMacAboutMenuItemId();
27947 wxPyEndAllowThreads(__tstate);
27948 if (PyErr_Occurred()) SWIG_fail;
27949 }
27950 resultobj = SWIG_From_long(static_cast< long >(result));
27951 return resultobj;
27952 fail:
27953 return NULL;
27954 }
27955
27956
27957 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27958 PyObject *resultobj = 0;
27959 long result;
27960
27961 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27962 {
27963 PyThreadState* __tstate = wxPyBeginAllowThreads();
27964 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27965 wxPyEndAllowThreads(__tstate);
27966 if (PyErr_Occurred()) SWIG_fail;
27967 }
27968 resultobj = SWIG_From_long(static_cast< long >(result));
27969 return resultobj;
27970 fail:
27971 return NULL;
27972 }
27973
27974
27975 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27976 PyObject *resultobj = 0;
27977 long result;
27978
27979 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27980 {
27981 PyThreadState* __tstate = wxPyBeginAllowThreads();
27982 result = (long)wxPyApp::GetMacExitMenuItemId();
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 resultobj = SWIG_From_long(static_cast< long >(result));
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27994 PyObject *resultobj = 0;
27995 wxString result;
27996
27997 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 result = wxPyApp::GetMacHelpMenuTitleName();
28001 wxPyEndAllowThreads(__tstate);
28002 if (PyErr_Occurred()) SWIG_fail;
28003 }
28004 {
28005 #if wxUSE_UNICODE
28006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28007 #else
28008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28009 #endif
28010 }
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj = 0;
28019 bool arg1 ;
28020 bool val1 ;
28021 int ecode1 = 0 ;
28022 PyObject * obj0 = 0 ;
28023 char * kwnames[] = {
28024 (char *) "val", NULL
28025 };
28026
28027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28028 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28029 if (!SWIG_IsOK(ecode1)) {
28030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28031 }
28032 arg1 = static_cast< bool >(val1);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 resultobj = SWIG_Py_Void();
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj = 0;
28048 long arg1 ;
28049 long val1 ;
28050 int ecode1 = 0 ;
28051 PyObject * obj0 = 0 ;
28052 char * kwnames[] = {
28053 (char *) "val", NULL
28054 };
28055
28056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28057 ecode1 = SWIG_AsVal_long(obj0, &val1);
28058 if (!SWIG_IsOK(ecode1)) {
28059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28060 }
28061 arg1 = static_cast< long >(val1);
28062 {
28063 PyThreadState* __tstate = wxPyBeginAllowThreads();
28064 wxPyApp::SetMacAboutMenuItemId(arg1);
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 resultobj = SWIG_Py_Void();
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28076 PyObject *resultobj = 0;
28077 long arg1 ;
28078 long val1 ;
28079 int ecode1 = 0 ;
28080 PyObject * obj0 = 0 ;
28081 char * kwnames[] = {
28082 (char *) "val", NULL
28083 };
28084
28085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28086 ecode1 = SWIG_AsVal_long(obj0, &val1);
28087 if (!SWIG_IsOK(ecode1)) {
28088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28089 }
28090 arg1 = static_cast< long >(val1);
28091 {
28092 PyThreadState* __tstate = wxPyBeginAllowThreads();
28093 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 resultobj = SWIG_Py_Void();
28098 return resultobj;
28099 fail:
28100 return NULL;
28101 }
28102
28103
28104 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28105 PyObject *resultobj = 0;
28106 long arg1 ;
28107 long val1 ;
28108 int ecode1 = 0 ;
28109 PyObject * obj0 = 0 ;
28110 char * kwnames[] = {
28111 (char *) "val", NULL
28112 };
28113
28114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28115 ecode1 = SWIG_AsVal_long(obj0, &val1);
28116 if (!SWIG_IsOK(ecode1)) {
28117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28118 }
28119 arg1 = static_cast< long >(val1);
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 wxPyApp::SetMacExitMenuItemId(arg1);
28123 wxPyEndAllowThreads(__tstate);
28124 if (PyErr_Occurred()) SWIG_fail;
28125 }
28126 resultobj = SWIG_Py_Void();
28127 return resultobj;
28128 fail:
28129 return NULL;
28130 }
28131
28132
28133 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28134 PyObject *resultobj = 0;
28135 wxString *arg1 = 0 ;
28136 bool temp1 = false ;
28137 PyObject * obj0 = 0 ;
28138 char * kwnames[] = {
28139 (char *) "val", NULL
28140 };
28141
28142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28143 {
28144 arg1 = wxString_in_helper(obj0);
28145 if (arg1 == NULL) SWIG_fail;
28146 temp1 = true;
28147 }
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_Py_Void();
28155 {
28156 if (temp1)
28157 delete arg1;
28158 }
28159 return resultobj;
28160 fail:
28161 {
28162 if (temp1)
28163 delete arg1;
28164 }
28165 return NULL;
28166 }
28167
28168
28169 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28170 PyObject *resultobj = 0;
28171 wxPyApp *arg1 = (wxPyApp *) 0 ;
28172 void *argp1 = 0 ;
28173 int res1 = 0 ;
28174 PyObject *swig_obj[1] ;
28175
28176 if (!args) SWIG_fail;
28177 swig_obj[0] = args;
28178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28179 if (!SWIG_IsOK(res1)) {
28180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28181 }
28182 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28183 {
28184 PyThreadState* __tstate = wxPyBeginAllowThreads();
28185 (arg1)->_BootstrapApp();
28186 wxPyEndAllowThreads(__tstate);
28187 if (PyErr_Occurred()) SWIG_fail;
28188 }
28189 resultobj = SWIG_Py_Void();
28190 return resultobj;
28191 fail:
28192 return NULL;
28193 }
28194
28195
28196 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28197 PyObject *resultobj = 0;
28198 int result;
28199
28200 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 result = (int)wxPyApp_GetComCtl32Version();
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 resultobj = SWIG_From_int(static_cast< int >(result));
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28215 PyObject *obj;
28216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28217 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28218 return SWIG_Py_Void();
28219 }
28220
28221 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28222 return SWIG_Python_InitShadowInstance(args);
28223 }
28224
28225 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28226 PyObject *resultobj = 0;
28227
28228 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 wxExit();
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 resultobj = SWIG_Py_Void();
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28243 PyObject *resultobj = 0;
28244 bool result;
28245
28246 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28247 {
28248 PyThreadState* __tstate = wxPyBeginAllowThreads();
28249 result = (bool)wxYield();
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 {
28254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28255 }
28256 return resultobj;
28257 fail:
28258 return NULL;
28259 }
28260
28261
28262 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28263 PyObject *resultobj = 0;
28264 bool result;
28265
28266 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 result = (bool)wxYieldIfNeeded();
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 {
28274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28275 }
28276 return resultobj;
28277 fail:
28278 return NULL;
28279 }
28280
28281
28282 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj = 0;
28284 wxWindow *arg1 = (wxWindow *) NULL ;
28285 bool arg2 = (bool) false ;
28286 bool result;
28287 void *argp1 = 0 ;
28288 int res1 = 0 ;
28289 bool val2 ;
28290 int ecode2 = 0 ;
28291 PyObject * obj0 = 0 ;
28292 PyObject * obj1 = 0 ;
28293 char * kwnames[] = {
28294 (char *) "win",(char *) "onlyIfNeeded", NULL
28295 };
28296
28297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28298 if (obj0) {
28299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28300 if (!SWIG_IsOK(res1)) {
28301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28302 }
28303 arg1 = reinterpret_cast< wxWindow * >(argp1);
28304 }
28305 if (obj1) {
28306 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28307 if (!SWIG_IsOK(ecode2)) {
28308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28309 }
28310 arg2 = static_cast< bool >(val2);
28311 }
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (bool)wxSafeYield(arg1,arg2);
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 {
28319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28320 }
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28328 PyObject *resultobj = 0;
28329
28330 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 wxWakeUpIdle();
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 resultobj = SWIG_Py_Void();
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28345 PyObject *resultobj = 0;
28346 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28347 wxEvent *arg2 = 0 ;
28348 void *argp1 = 0 ;
28349 int res1 = 0 ;
28350 void *argp2 = 0 ;
28351 int res2 = 0 ;
28352 PyObject * obj0 = 0 ;
28353 PyObject * obj1 = 0 ;
28354 char * kwnames[] = {
28355 (char *) "dest",(char *) "event", NULL
28356 };
28357
28358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28360 if (!SWIG_IsOK(res1)) {
28361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28362 }
28363 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28365 if (!SWIG_IsOK(res2)) {
28366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28367 }
28368 if (!argp2) {
28369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28370 }
28371 arg2 = reinterpret_cast< wxEvent * >(argp2);
28372 {
28373 PyThreadState* __tstate = wxPyBeginAllowThreads();
28374 wxPostEvent(arg1,*arg2);
28375 wxPyEndAllowThreads(__tstate);
28376 if (PyErr_Occurred()) SWIG_fail;
28377 }
28378 resultobj = SWIG_Py_Void();
28379 return resultobj;
28380 fail:
28381 return NULL;
28382 }
28383
28384
28385 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28386 PyObject *resultobj = 0;
28387
28388 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28389 {
28390 PyThreadState* __tstate = wxPyBeginAllowThreads();
28391 wxApp_CleanUp();
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 resultobj = SWIG_Py_Void();
28396 return resultobj;
28397 fail:
28398 return NULL;
28399 }
28400
28401
28402 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28403 PyObject *resultobj = 0;
28404 wxPyApp *result = 0 ;
28405
28406 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28407 {
28408 PyThreadState* __tstate = wxPyBeginAllowThreads();
28409 result = (wxPyApp *)wxPyGetApp();
28410 wxPyEndAllowThreads(__tstate);
28411 if (PyErr_Occurred()) SWIG_fail;
28412 }
28413 {
28414 resultobj = wxPyMake_wxObject(result, 0);
28415 }
28416 return resultobj;
28417 fail:
28418 return NULL;
28419 }
28420
28421
28422 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28423 PyObject *resultobj = 0;
28424 char *arg1 = (char *) 0 ;
28425 int res1 ;
28426 char *buf1 = 0 ;
28427 int alloc1 = 0 ;
28428 PyObject * obj0 = 0 ;
28429 char * kwnames[] = {
28430 (char *) "encoding", NULL
28431 };
28432
28433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28434 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28435 if (!SWIG_IsOK(res1)) {
28436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28437 }
28438 arg1 = buf1;
28439 {
28440 PyThreadState* __tstate = wxPyBeginAllowThreads();
28441 wxSetDefaultPyEncoding((char const *)arg1);
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 resultobj = SWIG_Py_Void();
28446 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28447 return resultobj;
28448 fail:
28449 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28450 return NULL;
28451 }
28452
28453
28454 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28455 PyObject *resultobj = 0;
28456 char *result = 0 ;
28457
28458 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 result = (char *)wxGetDefaultPyEncoding();
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 resultobj = SWIG_FromCharPtr(result);
28466 return resultobj;
28467 fail:
28468 return NULL;
28469 }
28470
28471
28472 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28473 PyObject *resultobj = 0;
28474 wxEventLoop *result = 0 ;
28475
28476 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 result = (wxEventLoop *)new wxEventLoop();
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28484 return resultobj;
28485 fail:
28486 return NULL;
28487 }
28488
28489
28490 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28491 PyObject *resultobj = 0;
28492 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28493 void *argp1 = 0 ;
28494 int res1 = 0 ;
28495 PyObject *swig_obj[1] ;
28496
28497 if (!args) SWIG_fail;
28498 swig_obj[0] = args;
28499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28500 if (!SWIG_IsOK(res1)) {
28501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28502 }
28503 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 delete arg1;
28507
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 resultobj = SWIG_Py_Void();
28512 return resultobj;
28513 fail:
28514 return NULL;
28515 }
28516
28517
28518 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28519 PyObject *resultobj = 0;
28520 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28521 int result;
28522 void *argp1 = 0 ;
28523 int res1 = 0 ;
28524 PyObject *swig_obj[1] ;
28525
28526 if (!args) SWIG_fail;
28527 swig_obj[0] = args;
28528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28529 if (!SWIG_IsOK(res1)) {
28530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28531 }
28532 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 result = (int)(arg1)->Run();
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 resultobj = SWIG_From_int(static_cast< int >(result));
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj = 0;
28548 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28549 int arg2 = (int) 0 ;
28550 void *argp1 = 0 ;
28551 int res1 = 0 ;
28552 int val2 ;
28553 int ecode2 = 0 ;
28554 PyObject * obj0 = 0 ;
28555 PyObject * obj1 = 0 ;
28556 char * kwnames[] = {
28557 (char *) "self",(char *) "rc", NULL
28558 };
28559
28560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28562 if (!SWIG_IsOK(res1)) {
28563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28564 }
28565 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28566 if (obj1) {
28567 ecode2 = SWIG_AsVal_int(obj1, &val2);
28568 if (!SWIG_IsOK(ecode2)) {
28569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28570 }
28571 arg2 = static_cast< int >(val2);
28572 }
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 (arg1)->Exit(arg2);
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 resultobj = SWIG_Py_Void();
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28587 PyObject *resultobj = 0;
28588 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28589 bool result;
28590 void *argp1 = 0 ;
28591 int res1 = 0 ;
28592 PyObject *swig_obj[1] ;
28593
28594 if (!args) SWIG_fail;
28595 swig_obj[0] = args;
28596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28597 if (!SWIG_IsOK(res1)) {
28598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28599 }
28600 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 result = (bool)((wxEventLoop const *)arg1)->Pending();
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 {
28608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28609 }
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28617 PyObject *resultobj = 0;
28618 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28619 bool result;
28620 void *argp1 = 0 ;
28621 int res1 = 0 ;
28622 PyObject *swig_obj[1] ;
28623
28624 if (!args) SWIG_fail;
28625 swig_obj[0] = args;
28626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28627 if (!SWIG_IsOK(res1)) {
28628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28629 }
28630 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = (bool)(arg1)->Dispatch();
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 {
28638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28639 }
28640 return resultobj;
28641 fail:
28642 return NULL;
28643 }
28644
28645
28646 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28647 PyObject *resultobj = 0;
28648 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28649 bool result;
28650 void *argp1 = 0 ;
28651 int res1 = 0 ;
28652 PyObject *swig_obj[1] ;
28653
28654 if (!args) SWIG_fail;
28655 swig_obj[0] = args;
28656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28657 if (!SWIG_IsOK(res1)) {
28658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28659 }
28660 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28661 {
28662 PyThreadState* __tstate = wxPyBeginAllowThreads();
28663 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28664 wxPyEndAllowThreads(__tstate);
28665 if (PyErr_Occurred()) SWIG_fail;
28666 }
28667 {
28668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28669 }
28670 return resultobj;
28671 fail:
28672 return NULL;
28673 }
28674
28675
28676 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28677 PyObject *resultobj = 0;
28678 wxEventLoop *result = 0 ;
28679
28680 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 result = (wxEventLoop *)wxEventLoop::GetActive();
28684 wxPyEndAllowThreads(__tstate);
28685 if (PyErr_Occurred()) SWIG_fail;
28686 }
28687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28688 return resultobj;
28689 fail:
28690 return NULL;
28691 }
28692
28693
28694 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28695 PyObject *resultobj = 0;
28696 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28697 void *argp1 = 0 ;
28698 int res1 = 0 ;
28699 PyObject * obj0 = 0 ;
28700 char * kwnames[] = {
28701 (char *) "loop", NULL
28702 };
28703
28704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28706 if (!SWIG_IsOK(res1)) {
28707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28708 }
28709 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28710 {
28711 PyThreadState* __tstate = wxPyBeginAllowThreads();
28712 wxEventLoop::SetActive(arg1);
28713 wxPyEndAllowThreads(__tstate);
28714 if (PyErr_Occurred()) SWIG_fail;
28715 }
28716 resultobj = SWIG_Py_Void();
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28724 PyObject *obj;
28725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28726 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28727 return SWIG_Py_Void();
28728 }
28729
28730 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 return SWIG_Python_InitShadowInstance(args);
28732 }
28733
28734 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28735 PyObject *resultobj = 0;
28736 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28737 wxEventLoopActivator *result = 0 ;
28738 void *argp1 = 0 ;
28739 int res1 = 0 ;
28740 PyObject * obj0 = 0 ;
28741 char * kwnames[] = {
28742 (char *) "evtLoop", NULL
28743 };
28744
28745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28747 if (!SWIG_IsOK(res1)) {
28748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28749 }
28750 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28765 PyObject *resultobj = 0;
28766 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28767 void *argp1 = 0 ;
28768 int res1 = 0 ;
28769 PyObject *swig_obj[1] ;
28770
28771 if (!args) SWIG_fail;
28772 swig_obj[0] = args;
28773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28774 if (!SWIG_IsOK(res1)) {
28775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28776 }
28777 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 delete arg1;
28781
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 resultobj = SWIG_Py_Void();
28786 return resultobj;
28787 fail:
28788 return NULL;
28789 }
28790
28791
28792 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28793 PyObject *obj;
28794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28795 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28796 return SWIG_Py_Void();
28797 }
28798
28799 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28800 return SWIG_Python_InitShadowInstance(args);
28801 }
28802
28803 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28804 PyObject *resultobj = 0;
28805 int arg1 = (int) 0 ;
28806 int arg2 = (int) 0 ;
28807 int arg3 = (int) 0 ;
28808 wxAcceleratorEntry *result = 0 ;
28809 int val1 ;
28810 int ecode1 = 0 ;
28811 int val2 ;
28812 int ecode2 = 0 ;
28813 int val3 ;
28814 int ecode3 = 0 ;
28815 PyObject * obj0 = 0 ;
28816 PyObject * obj1 = 0 ;
28817 PyObject * obj2 = 0 ;
28818 char * kwnames[] = {
28819 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28820 };
28821
28822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28823 if (obj0) {
28824 ecode1 = SWIG_AsVal_int(obj0, &val1);
28825 if (!SWIG_IsOK(ecode1)) {
28826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28827 }
28828 arg1 = static_cast< int >(val1);
28829 }
28830 if (obj1) {
28831 ecode2 = SWIG_AsVal_int(obj1, &val2);
28832 if (!SWIG_IsOK(ecode2)) {
28833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28834 }
28835 arg2 = static_cast< int >(val2);
28836 }
28837 if (obj2) {
28838 ecode3 = SWIG_AsVal_int(obj2, &val3);
28839 if (!SWIG_IsOK(ecode3)) {
28840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28841 }
28842 arg3 = static_cast< int >(val3);
28843 }
28844 {
28845 PyThreadState* __tstate = wxPyBeginAllowThreads();
28846 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28858 PyObject *resultobj = 0;
28859 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28860 void *argp1 = 0 ;
28861 int res1 = 0 ;
28862 PyObject *swig_obj[1] ;
28863
28864 if (!args) SWIG_fail;
28865 swig_obj[0] = args;
28866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28867 if (!SWIG_IsOK(res1)) {
28868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28869 }
28870 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 delete arg1;
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 resultobj = SWIG_Py_Void();
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28886 PyObject *resultobj = 0;
28887 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28888 int arg2 ;
28889 int arg3 ;
28890 int arg4 ;
28891 void *argp1 = 0 ;
28892 int res1 = 0 ;
28893 int val2 ;
28894 int ecode2 = 0 ;
28895 int val3 ;
28896 int ecode3 = 0 ;
28897 int val4 ;
28898 int ecode4 = 0 ;
28899 PyObject * obj0 = 0 ;
28900 PyObject * obj1 = 0 ;
28901 PyObject * obj2 = 0 ;
28902 PyObject * obj3 = 0 ;
28903 char * kwnames[] = {
28904 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28905 };
28906
28907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28909 if (!SWIG_IsOK(res1)) {
28910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28911 }
28912 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28913 ecode2 = SWIG_AsVal_int(obj1, &val2);
28914 if (!SWIG_IsOK(ecode2)) {
28915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28916 }
28917 arg2 = static_cast< int >(val2);
28918 ecode3 = SWIG_AsVal_int(obj2, &val3);
28919 if (!SWIG_IsOK(ecode3)) {
28920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28921 }
28922 arg3 = static_cast< int >(val3);
28923 ecode4 = SWIG_AsVal_int(obj3, &val4);
28924 if (!SWIG_IsOK(ecode4)) {
28925 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28926 }
28927 arg4 = static_cast< int >(val4);
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 (arg1)->Set(arg2,arg3,arg4);
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 resultobj = SWIG_Py_Void();
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28942 PyObject *resultobj = 0;
28943 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28944 int result;
28945 void *argp1 = 0 ;
28946 int res1 = 0 ;
28947 PyObject *swig_obj[1] ;
28948
28949 if (!args) SWIG_fail;
28950 swig_obj[0] = args;
28951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28952 if (!SWIG_IsOK(res1)) {
28953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28954 }
28955 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 result = (int)(arg1)->GetFlags();
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_From_int(static_cast< int >(result));
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *resultobj = 0;
28971 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28972 int result;
28973 void *argp1 = 0 ;
28974 int res1 = 0 ;
28975 PyObject *swig_obj[1] ;
28976
28977 if (!args) SWIG_fail;
28978 swig_obj[0] = args;
28979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28980 if (!SWIG_IsOK(res1)) {
28981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28982 }
28983 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (int)(arg1)->GetKeyCode();
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_From_int(static_cast< int >(result));
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29000 int result;
29001 void *argp1 = 0 ;
29002 int res1 = 0 ;
29003 PyObject *swig_obj[1] ;
29004
29005 if (!args) SWIG_fail;
29006 swig_obj[0] = args;
29007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29008 if (!SWIG_IsOK(res1)) {
29009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29010 }
29011 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (int)(arg1)->GetCommand();
29015 wxPyEndAllowThreads(__tstate);
29016 if (PyErr_Occurred()) SWIG_fail;
29017 }
29018 resultobj = SWIG_From_int(static_cast< int >(result));
29019 return resultobj;
29020 fail:
29021 return NULL;
29022 }
29023
29024
29025 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29026 PyObject *obj;
29027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29028 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29029 return SWIG_Py_Void();
29030 }
29031
29032 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29033 return SWIG_Python_InitShadowInstance(args);
29034 }
29035
29036 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29037 PyObject *resultobj = 0;
29038 int arg1 ;
29039 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29040 wxAcceleratorTable *result = 0 ;
29041 PyObject * obj0 = 0 ;
29042 char * kwnames[] = {
29043 (char *) "n", NULL
29044 };
29045
29046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29047 {
29048 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29049 if (arg2) arg1 = PyList_Size(obj0);
29050 else arg1 = 0;
29051 }
29052 {
29053 PyThreadState* __tstate = wxPyBeginAllowThreads();
29054 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29059 return resultobj;
29060 fail:
29061 return NULL;
29062 }
29063
29064
29065 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29066 PyObject *resultobj = 0;
29067 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29068 void *argp1 = 0 ;
29069 int res1 = 0 ;
29070 PyObject *swig_obj[1] ;
29071
29072 if (!args) SWIG_fail;
29073 swig_obj[0] = args;
29074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29075 if (!SWIG_IsOK(res1)) {
29076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29077 }
29078 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 delete arg1;
29082
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 resultobj = SWIG_Py_Void();
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29094 PyObject *resultobj = 0;
29095 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29096 bool result;
29097 void *argp1 = 0 ;
29098 int res1 = 0 ;
29099 PyObject *swig_obj[1] ;
29100
29101 if (!args) SWIG_fail;
29102 swig_obj[0] = args;
29103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29104 if (!SWIG_IsOK(res1)) {
29105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29106 }
29107 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 {
29115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29116 }
29117 return resultobj;
29118 fail:
29119 return NULL;
29120 }
29121
29122
29123 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29124 PyObject *obj;
29125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29126 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29127 return SWIG_Py_Void();
29128 }
29129
29130 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29131 return SWIG_Python_InitShadowInstance(args);
29132 }
29133
29134 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29135 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29136 return 1;
29137 }
29138
29139
29140 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29141 PyObject *pyobj = 0;
29142
29143 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29144 return pyobj;
29145 }
29146
29147
29148 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29149 PyObject *resultobj = 0;
29150 wxString *arg1 = 0 ;
29151 wxAcceleratorEntry *result = 0 ;
29152 bool temp1 = false ;
29153 PyObject * obj0 = 0 ;
29154 char * kwnames[] = {
29155 (char *) "label", NULL
29156 };
29157
29158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29159 {
29160 arg1 = wxString_in_helper(obj0);
29161 if (arg1 == NULL) SWIG_fail;
29162 temp1 = true;
29163 }
29164 {
29165 PyThreadState* __tstate = wxPyBeginAllowThreads();
29166 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29167 wxPyEndAllowThreads(__tstate);
29168 if (PyErr_Occurred()) SWIG_fail;
29169 }
29170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29171 {
29172 if (temp1)
29173 delete arg1;
29174 }
29175 return resultobj;
29176 fail:
29177 {
29178 if (temp1)
29179 delete arg1;
29180 }
29181 return NULL;
29182 }
29183
29184
29185 SWIGINTERN int PanelNameStr_set(PyObject *) {
29186 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29187 return 1;
29188 }
29189
29190
29191 SWIGINTERN PyObject *PanelNameStr_get(void) {
29192 PyObject *pyobj = 0;
29193
29194 {
29195 #if wxUSE_UNICODE
29196 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29197 #else
29198 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29199 #endif
29200 }
29201 return pyobj;
29202 }
29203
29204
29205 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29206 PyObject *resultobj = 0;
29207 wxVisualAttributes *result = 0 ;
29208
29209 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29210 {
29211 PyThreadState* __tstate = wxPyBeginAllowThreads();
29212 result = (wxVisualAttributes *)new_wxVisualAttributes();
29213 wxPyEndAllowThreads(__tstate);
29214 if (PyErr_Occurred()) SWIG_fail;
29215 }
29216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29224 PyObject *resultobj = 0;
29225 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29226 void *argp1 = 0 ;
29227 int res1 = 0 ;
29228 PyObject *swig_obj[1] ;
29229
29230 if (!args) SWIG_fail;
29231 swig_obj[0] = args;
29232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29233 if (!SWIG_IsOK(res1)) {
29234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29235 }
29236 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29237 {
29238 PyThreadState* __tstate = wxPyBeginAllowThreads();
29239 delete_wxVisualAttributes(arg1);
29240
29241 wxPyEndAllowThreads(__tstate);
29242 if (PyErr_Occurred()) SWIG_fail;
29243 }
29244 resultobj = SWIG_Py_Void();
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29252 PyObject *resultobj = 0;
29253 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29254 wxFont *arg2 = (wxFont *) 0 ;
29255 void *argp1 = 0 ;
29256 int res1 = 0 ;
29257 void *argp2 = 0 ;
29258 int res2 = 0 ;
29259 PyObject *swig_obj[2] ;
29260
29261 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29263 if (!SWIG_IsOK(res1)) {
29264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29265 }
29266 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29267 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29268 if (!SWIG_IsOK(res2)) {
29269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29270 }
29271 arg2 = reinterpret_cast< wxFont * >(argp2);
29272 if (arg1) (arg1)->font = *arg2;
29273
29274 resultobj = SWIG_Py_Void();
29275 return resultobj;
29276 fail:
29277 return NULL;
29278 }
29279
29280
29281 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29282 PyObject *resultobj = 0;
29283 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29284 wxFont *result = 0 ;
29285 void *argp1 = 0 ;
29286 int res1 = 0 ;
29287 PyObject *swig_obj[1] ;
29288
29289 if (!args) SWIG_fail;
29290 swig_obj[0] = args;
29291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29294 }
29295 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29296 result = (wxFont *)& ((arg1)->font);
29297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29298 return resultobj;
29299 fail:
29300 return NULL;
29301 }
29302
29303
29304 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29305 PyObject *resultobj = 0;
29306 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29307 wxColour *arg2 = (wxColour *) 0 ;
29308 void *argp1 = 0 ;
29309 int res1 = 0 ;
29310 void *argp2 = 0 ;
29311 int res2 = 0 ;
29312 PyObject *swig_obj[2] ;
29313
29314 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29316 if (!SWIG_IsOK(res1)) {
29317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29318 }
29319 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29320 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29321 if (!SWIG_IsOK(res2)) {
29322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29323 }
29324 arg2 = reinterpret_cast< wxColour * >(argp2);
29325 if (arg1) (arg1)->colFg = *arg2;
29326
29327 resultobj = SWIG_Py_Void();
29328 return resultobj;
29329 fail:
29330 return NULL;
29331 }
29332
29333
29334 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29335 PyObject *resultobj = 0;
29336 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29337 wxColour *result = 0 ;
29338 void *argp1 = 0 ;
29339 int res1 = 0 ;
29340 PyObject *swig_obj[1] ;
29341
29342 if (!args) SWIG_fail;
29343 swig_obj[0] = args;
29344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29345 if (!SWIG_IsOK(res1)) {
29346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29347 }
29348 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29349 result = (wxColour *)& ((arg1)->colFg);
29350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29351 return resultobj;
29352 fail:
29353 return NULL;
29354 }
29355
29356
29357 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29358 PyObject *resultobj = 0;
29359 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29360 wxColour *arg2 = (wxColour *) 0 ;
29361 void *argp1 = 0 ;
29362 int res1 = 0 ;
29363 void *argp2 = 0 ;
29364 int res2 = 0 ;
29365 PyObject *swig_obj[2] ;
29366
29367 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29369 if (!SWIG_IsOK(res1)) {
29370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29371 }
29372 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29373 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29374 if (!SWIG_IsOK(res2)) {
29375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29376 }
29377 arg2 = reinterpret_cast< wxColour * >(argp2);
29378 if (arg1) (arg1)->colBg = *arg2;
29379
29380 resultobj = SWIG_Py_Void();
29381 return resultobj;
29382 fail:
29383 return NULL;
29384 }
29385
29386
29387 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29388 PyObject *resultobj = 0;
29389 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29390 wxColour *result = 0 ;
29391 void *argp1 = 0 ;
29392 int res1 = 0 ;
29393 PyObject *swig_obj[1] ;
29394
29395 if (!args) SWIG_fail;
29396 swig_obj[0] = args;
29397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29398 if (!SWIG_IsOK(res1)) {
29399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29400 }
29401 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29402 result = (wxColour *)& ((arg1)->colBg);
29403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29411 PyObject *obj;
29412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29413 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29414 return SWIG_Py_Void();
29415 }
29416
29417 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29418 return SWIG_Python_InitShadowInstance(args);
29419 }
29420
29421 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29422 PyObject *resultobj = 0;
29423 wxWindow *arg1 = (wxWindow *) 0 ;
29424 int arg2 = (int) (int)-1 ;
29425 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29426 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29427 wxSize const &arg4_defvalue = wxDefaultSize ;
29428 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29429 long arg5 = (long) 0 ;
29430 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29431 wxString *arg6 = (wxString *) &arg6_defvalue ;
29432 wxWindow *result = 0 ;
29433 void *argp1 = 0 ;
29434 int res1 = 0 ;
29435 int val2 ;
29436 int ecode2 = 0 ;
29437 wxPoint temp3 ;
29438 wxSize temp4 ;
29439 long val5 ;
29440 int ecode5 = 0 ;
29441 bool temp6 = false ;
29442 PyObject * obj0 = 0 ;
29443 PyObject * obj1 = 0 ;
29444 PyObject * obj2 = 0 ;
29445 PyObject * obj3 = 0 ;
29446 PyObject * obj4 = 0 ;
29447 PyObject * obj5 = 0 ;
29448 char * kwnames[] = {
29449 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29450 };
29451
29452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29454 if (!SWIG_IsOK(res1)) {
29455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29456 }
29457 arg1 = reinterpret_cast< wxWindow * >(argp1);
29458 if (obj1) {
29459 ecode2 = SWIG_AsVal_int(obj1, &val2);
29460 if (!SWIG_IsOK(ecode2)) {
29461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29462 }
29463 arg2 = static_cast< int >(val2);
29464 }
29465 if (obj2) {
29466 {
29467 arg3 = &temp3;
29468 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29469 }
29470 }
29471 if (obj3) {
29472 {
29473 arg4 = &temp4;
29474 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29475 }
29476 }
29477 if (obj4) {
29478 ecode5 = SWIG_AsVal_long(obj4, &val5);
29479 if (!SWIG_IsOK(ecode5)) {
29480 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29481 }
29482 arg5 = static_cast< long >(val5);
29483 }
29484 if (obj5) {
29485 {
29486 arg6 = wxString_in_helper(obj5);
29487 if (arg6 == NULL) SWIG_fail;
29488 temp6 = true;
29489 }
29490 }
29491 {
29492 if (!wxPyCheckForApp()) SWIG_fail;
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29495 wxPyEndAllowThreads(__tstate);
29496 if (PyErr_Occurred()) SWIG_fail;
29497 }
29498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29499 {
29500 if (temp6)
29501 delete arg6;
29502 }
29503 return resultobj;
29504 fail:
29505 {
29506 if (temp6)
29507 delete arg6;
29508 }
29509 return NULL;
29510 }
29511
29512
29513 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29514 PyObject *resultobj = 0;
29515 wxWindow *result = 0 ;
29516
29517 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29518 {
29519 if (!wxPyCheckForApp()) SWIG_fail;
29520 PyThreadState* __tstate = wxPyBeginAllowThreads();
29521 result = (wxWindow *)new wxWindow();
29522 wxPyEndAllowThreads(__tstate);
29523 if (PyErr_Occurred()) SWIG_fail;
29524 }
29525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29526 return resultobj;
29527 fail:
29528 return NULL;
29529 }
29530
29531
29532 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29533 PyObject *resultobj = 0;
29534 wxWindow *arg1 = (wxWindow *) 0 ;
29535 wxWindow *arg2 = (wxWindow *) 0 ;
29536 int arg3 = (int) (int)-1 ;
29537 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29538 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29539 wxSize const &arg5_defvalue = wxDefaultSize ;
29540 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29541 long arg6 = (long) 0 ;
29542 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29543 wxString *arg7 = (wxString *) &arg7_defvalue ;
29544 bool result;
29545 void *argp1 = 0 ;
29546 int res1 = 0 ;
29547 void *argp2 = 0 ;
29548 int res2 = 0 ;
29549 int val3 ;
29550 int ecode3 = 0 ;
29551 wxPoint temp4 ;
29552 wxSize temp5 ;
29553 long val6 ;
29554 int ecode6 = 0 ;
29555 bool temp7 = false ;
29556 PyObject * obj0 = 0 ;
29557 PyObject * obj1 = 0 ;
29558 PyObject * obj2 = 0 ;
29559 PyObject * obj3 = 0 ;
29560 PyObject * obj4 = 0 ;
29561 PyObject * obj5 = 0 ;
29562 PyObject * obj6 = 0 ;
29563 char * kwnames[] = {
29564 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29565 };
29566
29567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29569 if (!SWIG_IsOK(res1)) {
29570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29571 }
29572 arg1 = reinterpret_cast< wxWindow * >(argp1);
29573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29574 if (!SWIG_IsOK(res2)) {
29575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29576 }
29577 arg2 = reinterpret_cast< wxWindow * >(argp2);
29578 if (obj2) {
29579 ecode3 = SWIG_AsVal_int(obj2, &val3);
29580 if (!SWIG_IsOK(ecode3)) {
29581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29582 }
29583 arg3 = static_cast< int >(val3);
29584 }
29585 if (obj3) {
29586 {
29587 arg4 = &temp4;
29588 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29589 }
29590 }
29591 if (obj4) {
29592 {
29593 arg5 = &temp5;
29594 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29595 }
29596 }
29597 if (obj5) {
29598 ecode6 = SWIG_AsVal_long(obj5, &val6);
29599 if (!SWIG_IsOK(ecode6)) {
29600 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29601 }
29602 arg6 = static_cast< long >(val6);
29603 }
29604 if (obj6) {
29605 {
29606 arg7 = wxString_in_helper(obj6);
29607 if (arg7 == NULL) SWIG_fail;
29608 temp7 = true;
29609 }
29610 }
29611 {
29612 PyThreadState* __tstate = wxPyBeginAllowThreads();
29613 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29614 wxPyEndAllowThreads(__tstate);
29615 if (PyErr_Occurred()) SWIG_fail;
29616 }
29617 {
29618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29619 }
29620 {
29621 if (temp7)
29622 delete arg7;
29623 }
29624 return resultobj;
29625 fail:
29626 {
29627 if (temp7)
29628 delete arg7;
29629 }
29630 return NULL;
29631 }
29632
29633
29634 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29635 PyObject *resultobj = 0;
29636 wxWindow *arg1 = (wxWindow *) 0 ;
29637 bool arg2 = (bool) false ;
29638 bool result;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 bool val2 ;
29642 int ecode2 = 0 ;
29643 PyObject * obj0 = 0 ;
29644 PyObject * obj1 = 0 ;
29645 char * kwnames[] = {
29646 (char *) "self",(char *) "force", NULL
29647 };
29648
29649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29651 if (!SWIG_IsOK(res1)) {
29652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29653 }
29654 arg1 = reinterpret_cast< wxWindow * >(argp1);
29655 if (obj1) {
29656 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29657 if (!SWIG_IsOK(ecode2)) {
29658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29659 }
29660 arg2 = static_cast< bool >(val2);
29661 }
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = (bool)(arg1)->Close(arg2);
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 {
29669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29670 }
29671 return resultobj;
29672 fail:
29673 return NULL;
29674 }
29675
29676
29677 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29678 PyObject *resultobj = 0;
29679 wxWindow *arg1 = (wxWindow *) 0 ;
29680 bool result;
29681 void *argp1 = 0 ;
29682 int res1 = 0 ;
29683 PyObject *swig_obj[1] ;
29684
29685 if (!args) SWIG_fail;
29686 swig_obj[0] = args;
29687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29688 if (!SWIG_IsOK(res1)) {
29689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29690 }
29691 arg1 = reinterpret_cast< wxWindow * >(argp1);
29692 {
29693 PyThreadState* __tstate = wxPyBeginAllowThreads();
29694 result = (bool)(arg1)->Destroy();
29695 wxPyEndAllowThreads(__tstate);
29696 if (PyErr_Occurred()) SWIG_fail;
29697 }
29698 {
29699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29700 }
29701 return resultobj;
29702 fail:
29703 return NULL;
29704 }
29705
29706
29707 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29708 PyObject *resultobj = 0;
29709 wxWindow *arg1 = (wxWindow *) 0 ;
29710 bool result;
29711 void *argp1 = 0 ;
29712 int res1 = 0 ;
29713 PyObject *swig_obj[1] ;
29714
29715 if (!args) SWIG_fail;
29716 swig_obj[0] = args;
29717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29718 if (!SWIG_IsOK(res1)) {
29719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29720 }
29721 arg1 = reinterpret_cast< wxWindow * >(argp1);
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 result = (bool)(arg1)->DestroyChildren();
29725 wxPyEndAllowThreads(__tstate);
29726 if (PyErr_Occurred()) SWIG_fail;
29727 }
29728 {
29729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29730 }
29731 return resultobj;
29732 fail:
29733 return NULL;
29734 }
29735
29736
29737 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29738 PyObject *resultobj = 0;
29739 wxWindow *arg1 = (wxWindow *) 0 ;
29740 bool result;
29741 void *argp1 = 0 ;
29742 int res1 = 0 ;
29743 PyObject *swig_obj[1] ;
29744
29745 if (!args) SWIG_fail;
29746 swig_obj[0] = args;
29747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29748 if (!SWIG_IsOK(res1)) {
29749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29750 }
29751 arg1 = reinterpret_cast< wxWindow * >(argp1);
29752 {
29753 PyThreadState* __tstate = wxPyBeginAllowThreads();
29754 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29755 wxPyEndAllowThreads(__tstate);
29756 if (PyErr_Occurred()) SWIG_fail;
29757 }
29758 {
29759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29760 }
29761 return resultobj;
29762 fail:
29763 return NULL;
29764 }
29765
29766
29767 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29768 PyObject *resultobj = 0;
29769 wxWindow *arg1 = (wxWindow *) 0 ;
29770 wxString *arg2 = 0 ;
29771 void *argp1 = 0 ;
29772 int res1 = 0 ;
29773 bool temp2 = false ;
29774 PyObject * obj0 = 0 ;
29775 PyObject * obj1 = 0 ;
29776 char * kwnames[] = {
29777 (char *) "self",(char *) "label", NULL
29778 };
29779
29780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29782 if (!SWIG_IsOK(res1)) {
29783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29784 }
29785 arg1 = reinterpret_cast< wxWindow * >(argp1);
29786 {
29787 arg2 = wxString_in_helper(obj1);
29788 if (arg2 == NULL) SWIG_fail;
29789 temp2 = true;
29790 }
29791 {
29792 PyThreadState* __tstate = wxPyBeginAllowThreads();
29793 (arg1)->SetLabel((wxString const &)*arg2);
29794 wxPyEndAllowThreads(__tstate);
29795 if (PyErr_Occurred()) SWIG_fail;
29796 }
29797 resultobj = SWIG_Py_Void();
29798 {
29799 if (temp2)
29800 delete arg2;
29801 }
29802 return resultobj;
29803 fail:
29804 {
29805 if (temp2)
29806 delete arg2;
29807 }
29808 return NULL;
29809 }
29810
29811
29812 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29813 PyObject *resultobj = 0;
29814 wxWindow *arg1 = (wxWindow *) 0 ;
29815 wxString result;
29816 void *argp1 = 0 ;
29817 int res1 = 0 ;
29818 PyObject *swig_obj[1] ;
29819
29820 if (!args) SWIG_fail;
29821 swig_obj[0] = args;
29822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29823 if (!SWIG_IsOK(res1)) {
29824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29825 }
29826 arg1 = reinterpret_cast< wxWindow * >(argp1);
29827 {
29828 PyThreadState* __tstate = wxPyBeginAllowThreads();
29829 result = ((wxWindow const *)arg1)->GetLabel();
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 {
29834 #if wxUSE_UNICODE
29835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29836 #else
29837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29838 #endif
29839 }
29840 return resultobj;
29841 fail:
29842 return NULL;
29843 }
29844
29845
29846 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29847 PyObject *resultobj = 0;
29848 wxWindow *arg1 = (wxWindow *) 0 ;
29849 wxString *arg2 = 0 ;
29850 void *argp1 = 0 ;
29851 int res1 = 0 ;
29852 bool temp2 = false ;
29853 PyObject * obj0 = 0 ;
29854 PyObject * obj1 = 0 ;
29855 char * kwnames[] = {
29856 (char *) "self",(char *) "name", NULL
29857 };
29858
29859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29861 if (!SWIG_IsOK(res1)) {
29862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29863 }
29864 arg1 = reinterpret_cast< wxWindow * >(argp1);
29865 {
29866 arg2 = wxString_in_helper(obj1);
29867 if (arg2 == NULL) SWIG_fail;
29868 temp2 = true;
29869 }
29870 {
29871 PyThreadState* __tstate = wxPyBeginAllowThreads();
29872 (arg1)->SetName((wxString const &)*arg2);
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 resultobj = SWIG_Py_Void();
29877 {
29878 if (temp2)
29879 delete arg2;
29880 }
29881 return resultobj;
29882 fail:
29883 {
29884 if (temp2)
29885 delete arg2;
29886 }
29887 return NULL;
29888 }
29889
29890
29891 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29892 PyObject *resultobj = 0;
29893 wxWindow *arg1 = (wxWindow *) 0 ;
29894 wxString result;
29895 void *argp1 = 0 ;
29896 int res1 = 0 ;
29897 PyObject *swig_obj[1] ;
29898
29899 if (!args) SWIG_fail;
29900 swig_obj[0] = args;
29901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29904 }
29905 arg1 = reinterpret_cast< wxWindow * >(argp1);
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 result = ((wxWindow const *)arg1)->GetName();
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 {
29913 #if wxUSE_UNICODE
29914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29915 #else
29916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29917 #endif
29918 }
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj = 0;
29927 wxWindow *arg1 = (wxWindow *) 0 ;
29928 wxWindowVariant arg2 ;
29929 void *argp1 = 0 ;
29930 int res1 = 0 ;
29931 int val2 ;
29932 int ecode2 = 0 ;
29933 PyObject * obj0 = 0 ;
29934 PyObject * obj1 = 0 ;
29935 char * kwnames[] = {
29936 (char *) "self",(char *) "variant", NULL
29937 };
29938
29939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29941 if (!SWIG_IsOK(res1)) {
29942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29943 }
29944 arg1 = reinterpret_cast< wxWindow * >(argp1);
29945 ecode2 = SWIG_AsVal_int(obj1, &val2);
29946 if (!SWIG_IsOK(ecode2)) {
29947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29948 }
29949 arg2 = static_cast< wxWindowVariant >(val2);
29950 {
29951 PyThreadState* __tstate = wxPyBeginAllowThreads();
29952 (arg1)->SetWindowVariant(arg2);
29953 wxPyEndAllowThreads(__tstate);
29954 if (PyErr_Occurred()) SWIG_fail;
29955 }
29956 resultobj = SWIG_Py_Void();
29957 return resultobj;
29958 fail:
29959 return NULL;
29960 }
29961
29962
29963 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29964 PyObject *resultobj = 0;
29965 wxWindow *arg1 = (wxWindow *) 0 ;
29966 wxWindowVariant result;
29967 void *argp1 = 0 ;
29968 int res1 = 0 ;
29969 PyObject *swig_obj[1] ;
29970
29971 if (!args) SWIG_fail;
29972 swig_obj[0] = args;
29973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29974 if (!SWIG_IsOK(res1)) {
29975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29976 }
29977 arg1 = reinterpret_cast< wxWindow * >(argp1);
29978 {
29979 PyThreadState* __tstate = wxPyBeginAllowThreads();
29980 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29981 wxPyEndAllowThreads(__tstate);
29982 if (PyErr_Occurred()) SWIG_fail;
29983 }
29984 resultobj = SWIG_From_int(static_cast< int >(result));
29985 return resultobj;
29986 fail:
29987 return NULL;
29988 }
29989
29990
29991 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29992 PyObject *resultobj = 0;
29993 wxWindow *arg1 = (wxWindow *) 0 ;
29994 int arg2 ;
29995 void *argp1 = 0 ;
29996 int res1 = 0 ;
29997 int val2 ;
29998 int ecode2 = 0 ;
29999 PyObject * obj0 = 0 ;
30000 PyObject * obj1 = 0 ;
30001 char * kwnames[] = {
30002 (char *) "self",(char *) "winid", NULL
30003 };
30004
30005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30007 if (!SWIG_IsOK(res1)) {
30008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30009 }
30010 arg1 = reinterpret_cast< wxWindow * >(argp1);
30011 ecode2 = SWIG_AsVal_int(obj1, &val2);
30012 if (!SWIG_IsOK(ecode2)) {
30013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30014 }
30015 arg2 = static_cast< int >(val2);
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 (arg1)->SetId(arg2);
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 resultobj = SWIG_Py_Void();
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30030 PyObject *resultobj = 0;
30031 wxWindow *arg1 = (wxWindow *) 0 ;
30032 int result;
30033 void *argp1 = 0 ;
30034 int res1 = 0 ;
30035 PyObject *swig_obj[1] ;
30036
30037 if (!args) SWIG_fail;
30038 swig_obj[0] = args;
30039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30040 if (!SWIG_IsOK(res1)) {
30041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30042 }
30043 arg1 = reinterpret_cast< wxWindow * >(argp1);
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 result = (int)((wxWindow const *)arg1)->GetId();
30047 wxPyEndAllowThreads(__tstate);
30048 if (PyErr_Occurred()) SWIG_fail;
30049 }
30050 resultobj = SWIG_From_int(static_cast< int >(result));
30051 return resultobj;
30052 fail:
30053 return NULL;
30054 }
30055
30056
30057 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30058 PyObject *resultobj = 0;
30059 int result;
30060
30061 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 result = (int)wxWindow::NewControlId();
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 resultobj = SWIG_From_int(static_cast< int >(result));
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30076 PyObject *resultobj = 0;
30077 int arg1 ;
30078 int result;
30079 int val1 ;
30080 int ecode1 = 0 ;
30081 PyObject * obj0 = 0 ;
30082 char * kwnames[] = {
30083 (char *) "winid", NULL
30084 };
30085
30086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30087 ecode1 = SWIG_AsVal_int(obj0, &val1);
30088 if (!SWIG_IsOK(ecode1)) {
30089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30090 }
30091 arg1 = static_cast< int >(val1);
30092 {
30093 PyThreadState* __tstate = wxPyBeginAllowThreads();
30094 result = (int)wxWindow::NextControlId(arg1);
30095 wxPyEndAllowThreads(__tstate);
30096 if (PyErr_Occurred()) SWIG_fail;
30097 }
30098 resultobj = SWIG_From_int(static_cast< int >(result));
30099 return resultobj;
30100 fail:
30101 return NULL;
30102 }
30103
30104
30105 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30106 PyObject *resultobj = 0;
30107 int arg1 ;
30108 int result;
30109 int val1 ;
30110 int ecode1 = 0 ;
30111 PyObject * obj0 = 0 ;
30112 char * kwnames[] = {
30113 (char *) "winid", NULL
30114 };
30115
30116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30117 ecode1 = SWIG_AsVal_int(obj0, &val1);
30118 if (!SWIG_IsOK(ecode1)) {
30119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30120 }
30121 arg1 = static_cast< int >(val1);
30122 {
30123 PyThreadState* __tstate = wxPyBeginAllowThreads();
30124 result = (int)wxWindow::PrevControlId(arg1);
30125 wxPyEndAllowThreads(__tstate);
30126 if (PyErr_Occurred()) SWIG_fail;
30127 }
30128 resultobj = SWIG_From_int(static_cast< int >(result));
30129 return resultobj;
30130 fail:
30131 return NULL;
30132 }
30133
30134
30135 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30136 PyObject *resultobj = 0;
30137 wxWindow *arg1 = (wxWindow *) 0 ;
30138 wxSize *arg2 = 0 ;
30139 void *argp1 = 0 ;
30140 int res1 = 0 ;
30141 wxSize temp2 ;
30142 PyObject * obj0 = 0 ;
30143 PyObject * obj1 = 0 ;
30144 char * kwnames[] = {
30145 (char *) "self",(char *) "size", NULL
30146 };
30147
30148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30150 if (!SWIG_IsOK(res1)) {
30151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30152 }
30153 arg1 = reinterpret_cast< wxWindow * >(argp1);
30154 {
30155 arg2 = &temp2;
30156 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30157 }
30158 {
30159 PyThreadState* __tstate = wxPyBeginAllowThreads();
30160 (arg1)->SetSize((wxSize const &)*arg2);
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 resultobj = SWIG_Py_Void();
30165 return resultobj;
30166 fail:
30167 return NULL;
30168 }
30169
30170
30171 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30172 PyObject *resultobj = 0;
30173 wxWindow *arg1 = (wxWindow *) 0 ;
30174 int arg2 ;
30175 int arg3 ;
30176 int arg4 ;
30177 int arg5 ;
30178 int arg6 = (int) wxSIZE_AUTO ;
30179 void *argp1 = 0 ;
30180 int res1 = 0 ;
30181 int val2 ;
30182 int ecode2 = 0 ;
30183 int val3 ;
30184 int ecode3 = 0 ;
30185 int val4 ;
30186 int ecode4 = 0 ;
30187 int val5 ;
30188 int ecode5 = 0 ;
30189 int val6 ;
30190 int ecode6 = 0 ;
30191 PyObject * obj0 = 0 ;
30192 PyObject * obj1 = 0 ;
30193 PyObject * obj2 = 0 ;
30194 PyObject * obj3 = 0 ;
30195 PyObject * obj4 = 0 ;
30196 PyObject * obj5 = 0 ;
30197 char * kwnames[] = {
30198 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30199 };
30200
30201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30203 if (!SWIG_IsOK(res1)) {
30204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30205 }
30206 arg1 = reinterpret_cast< wxWindow * >(argp1);
30207 ecode2 = SWIG_AsVal_int(obj1, &val2);
30208 if (!SWIG_IsOK(ecode2)) {
30209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30210 }
30211 arg2 = static_cast< int >(val2);
30212 ecode3 = SWIG_AsVal_int(obj2, &val3);
30213 if (!SWIG_IsOK(ecode3)) {
30214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30215 }
30216 arg3 = static_cast< int >(val3);
30217 ecode4 = SWIG_AsVal_int(obj3, &val4);
30218 if (!SWIG_IsOK(ecode4)) {
30219 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30220 }
30221 arg4 = static_cast< int >(val4);
30222 ecode5 = SWIG_AsVal_int(obj4, &val5);
30223 if (!SWIG_IsOK(ecode5)) {
30224 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30225 }
30226 arg5 = static_cast< int >(val5);
30227 if (obj5) {
30228 ecode6 = SWIG_AsVal_int(obj5, &val6);
30229 if (!SWIG_IsOK(ecode6)) {
30230 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30231 }
30232 arg6 = static_cast< int >(val6);
30233 }
30234 {
30235 PyThreadState* __tstate = wxPyBeginAllowThreads();
30236 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 resultobj = SWIG_Py_Void();
30241 return resultobj;
30242 fail:
30243 return NULL;
30244 }
30245
30246
30247 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30248 PyObject *resultobj = 0;
30249 wxWindow *arg1 = (wxWindow *) 0 ;
30250 wxRect *arg2 = 0 ;
30251 int arg3 = (int) wxSIZE_AUTO ;
30252 void *argp1 = 0 ;
30253 int res1 = 0 ;
30254 wxRect temp2 ;
30255 int val3 ;
30256 int ecode3 = 0 ;
30257 PyObject * obj0 = 0 ;
30258 PyObject * obj1 = 0 ;
30259 PyObject * obj2 = 0 ;
30260 char * kwnames[] = {
30261 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30262 };
30263
30264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30266 if (!SWIG_IsOK(res1)) {
30267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30268 }
30269 arg1 = reinterpret_cast< wxWindow * >(argp1);
30270 {
30271 arg2 = &temp2;
30272 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30273 }
30274 if (obj2) {
30275 ecode3 = SWIG_AsVal_int(obj2, &val3);
30276 if (!SWIG_IsOK(ecode3)) {
30277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30278 }
30279 arg3 = static_cast< int >(val3);
30280 }
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 resultobj = SWIG_Py_Void();
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30295 PyObject *resultobj = 0;
30296 wxWindow *arg1 = (wxWindow *) 0 ;
30297 int arg2 ;
30298 int arg3 ;
30299 void *argp1 = 0 ;
30300 int res1 = 0 ;
30301 int val2 ;
30302 int ecode2 = 0 ;
30303 int val3 ;
30304 int ecode3 = 0 ;
30305 PyObject * obj0 = 0 ;
30306 PyObject * obj1 = 0 ;
30307 PyObject * obj2 = 0 ;
30308 char * kwnames[] = {
30309 (char *) "self",(char *) "width",(char *) "height", NULL
30310 };
30311
30312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30314 if (!SWIG_IsOK(res1)) {
30315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30316 }
30317 arg1 = reinterpret_cast< wxWindow * >(argp1);
30318 ecode2 = SWIG_AsVal_int(obj1, &val2);
30319 if (!SWIG_IsOK(ecode2)) {
30320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30321 }
30322 arg2 = static_cast< int >(val2);
30323 ecode3 = SWIG_AsVal_int(obj2, &val3);
30324 if (!SWIG_IsOK(ecode3)) {
30325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30326 }
30327 arg3 = static_cast< int >(val3);
30328 {
30329 PyThreadState* __tstate = wxPyBeginAllowThreads();
30330 (arg1)->SetSize(arg2,arg3);
30331 wxPyEndAllowThreads(__tstate);
30332 if (PyErr_Occurred()) SWIG_fail;
30333 }
30334 resultobj = SWIG_Py_Void();
30335 return resultobj;
30336 fail:
30337 return NULL;
30338 }
30339
30340
30341 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj = 0;
30343 wxWindow *arg1 = (wxWindow *) 0 ;
30344 wxPoint *arg2 = 0 ;
30345 int arg3 = (int) wxSIZE_USE_EXISTING ;
30346 void *argp1 = 0 ;
30347 int res1 = 0 ;
30348 wxPoint temp2 ;
30349 int val3 ;
30350 int ecode3 = 0 ;
30351 PyObject * obj0 = 0 ;
30352 PyObject * obj1 = 0 ;
30353 PyObject * obj2 = 0 ;
30354 char * kwnames[] = {
30355 (char *) "self",(char *) "pt",(char *) "flags", NULL
30356 };
30357
30358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30360 if (!SWIG_IsOK(res1)) {
30361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30362 }
30363 arg1 = reinterpret_cast< wxWindow * >(argp1);
30364 {
30365 arg2 = &temp2;
30366 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30367 }
30368 if (obj2) {
30369 ecode3 = SWIG_AsVal_int(obj2, &val3);
30370 if (!SWIG_IsOK(ecode3)) {
30371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30372 }
30373 arg3 = static_cast< int >(val3);
30374 }
30375 {
30376 PyThreadState* __tstate = wxPyBeginAllowThreads();
30377 (arg1)->Move((wxPoint const &)*arg2,arg3);
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 resultobj = SWIG_Py_Void();
30382 return resultobj;
30383 fail:
30384 return NULL;
30385 }
30386
30387
30388 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30389 PyObject *resultobj = 0;
30390 wxWindow *arg1 = (wxWindow *) 0 ;
30391 int arg2 ;
30392 int arg3 ;
30393 int arg4 = (int) wxSIZE_USE_EXISTING ;
30394 void *argp1 = 0 ;
30395 int res1 = 0 ;
30396 int val2 ;
30397 int ecode2 = 0 ;
30398 int val3 ;
30399 int ecode3 = 0 ;
30400 int val4 ;
30401 int ecode4 = 0 ;
30402 PyObject * obj0 = 0 ;
30403 PyObject * obj1 = 0 ;
30404 PyObject * obj2 = 0 ;
30405 PyObject * obj3 = 0 ;
30406 char * kwnames[] = {
30407 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30408 };
30409
30410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30412 if (!SWIG_IsOK(res1)) {
30413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30414 }
30415 arg1 = reinterpret_cast< wxWindow * >(argp1);
30416 ecode2 = SWIG_AsVal_int(obj1, &val2);
30417 if (!SWIG_IsOK(ecode2)) {
30418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30419 }
30420 arg2 = static_cast< int >(val2);
30421 ecode3 = SWIG_AsVal_int(obj2, &val3);
30422 if (!SWIG_IsOK(ecode3)) {
30423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30424 }
30425 arg3 = static_cast< int >(val3);
30426 if (obj3) {
30427 ecode4 = SWIG_AsVal_int(obj3, &val4);
30428 if (!SWIG_IsOK(ecode4)) {
30429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30430 }
30431 arg4 = static_cast< int >(val4);
30432 }
30433 {
30434 PyThreadState* __tstate = wxPyBeginAllowThreads();
30435 (arg1)->Move(arg2,arg3,arg4);
30436 wxPyEndAllowThreads(__tstate);
30437 if (PyErr_Occurred()) SWIG_fail;
30438 }
30439 resultobj = SWIG_Py_Void();
30440 return resultobj;
30441 fail:
30442 return NULL;
30443 }
30444
30445
30446 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30447 PyObject *resultobj = 0;
30448 wxWindow *arg1 = (wxWindow *) 0 ;
30449 wxSize const &arg2_defvalue = wxDefaultSize ;
30450 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30451 void *argp1 = 0 ;
30452 int res1 = 0 ;
30453 wxSize temp2 ;
30454 PyObject * obj0 = 0 ;
30455 PyObject * obj1 = 0 ;
30456 char * kwnames[] = {
30457 (char *) "self",(char *) "size", NULL
30458 };
30459
30460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30462 if (!SWIG_IsOK(res1)) {
30463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30464 }
30465 arg1 = reinterpret_cast< wxWindow * >(argp1);
30466 if (obj1) {
30467 {
30468 arg2 = &temp2;
30469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30470 }
30471 }
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 resultobj = SWIG_Py_Void();
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30486 PyObject *resultobj = 0;
30487 wxWindow *arg1 = (wxWindow *) 0 ;
30488 void *argp1 = 0 ;
30489 int res1 = 0 ;
30490 PyObject *swig_obj[1] ;
30491
30492 if (!args) SWIG_fail;
30493 swig_obj[0] = args;
30494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30495 if (!SWIG_IsOK(res1)) {
30496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30497 }
30498 arg1 = reinterpret_cast< wxWindow * >(argp1);
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 (arg1)->Raise();
30502 wxPyEndAllowThreads(__tstate);
30503 if (PyErr_Occurred()) SWIG_fail;
30504 }
30505 resultobj = SWIG_Py_Void();
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30513 PyObject *resultobj = 0;
30514 wxWindow *arg1 = (wxWindow *) 0 ;
30515 void *argp1 = 0 ;
30516 int res1 = 0 ;
30517 PyObject *swig_obj[1] ;
30518
30519 if (!args) SWIG_fail;
30520 swig_obj[0] = args;
30521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30522 if (!SWIG_IsOK(res1)) {
30523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30524 }
30525 arg1 = reinterpret_cast< wxWindow * >(argp1);
30526 {
30527 PyThreadState* __tstate = wxPyBeginAllowThreads();
30528 (arg1)->Lower();
30529 wxPyEndAllowThreads(__tstate);
30530 if (PyErr_Occurred()) SWIG_fail;
30531 }
30532 resultobj = SWIG_Py_Void();
30533 return resultobj;
30534 fail:
30535 return NULL;
30536 }
30537
30538
30539 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30540 PyObject *resultobj = 0;
30541 wxWindow *arg1 = (wxWindow *) 0 ;
30542 wxSize *arg2 = 0 ;
30543 void *argp1 = 0 ;
30544 int res1 = 0 ;
30545 wxSize temp2 ;
30546 PyObject * obj0 = 0 ;
30547 PyObject * obj1 = 0 ;
30548 char * kwnames[] = {
30549 (char *) "self",(char *) "size", NULL
30550 };
30551
30552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30554 if (!SWIG_IsOK(res1)) {
30555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30556 }
30557 arg1 = reinterpret_cast< wxWindow * >(argp1);
30558 {
30559 arg2 = &temp2;
30560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30561 }
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 (arg1)->SetClientSize((wxSize const &)*arg2);
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 resultobj = SWIG_Py_Void();
30569 return resultobj;
30570 fail:
30571 return NULL;
30572 }
30573
30574
30575 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30576 PyObject *resultobj = 0;
30577 wxWindow *arg1 = (wxWindow *) 0 ;
30578 int arg2 ;
30579 int arg3 ;
30580 void *argp1 = 0 ;
30581 int res1 = 0 ;
30582 int val2 ;
30583 int ecode2 = 0 ;
30584 int val3 ;
30585 int ecode3 = 0 ;
30586 PyObject * obj0 = 0 ;
30587 PyObject * obj1 = 0 ;
30588 PyObject * obj2 = 0 ;
30589 char * kwnames[] = {
30590 (char *) "self",(char *) "width",(char *) "height", NULL
30591 };
30592
30593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30597 }
30598 arg1 = reinterpret_cast< wxWindow * >(argp1);
30599 ecode2 = SWIG_AsVal_int(obj1, &val2);
30600 if (!SWIG_IsOK(ecode2)) {
30601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30602 }
30603 arg2 = static_cast< int >(val2);
30604 ecode3 = SWIG_AsVal_int(obj2, &val3);
30605 if (!SWIG_IsOK(ecode3)) {
30606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30607 }
30608 arg3 = static_cast< int >(val3);
30609 {
30610 PyThreadState* __tstate = wxPyBeginAllowThreads();
30611 (arg1)->SetClientSize(arg2,arg3);
30612 wxPyEndAllowThreads(__tstate);
30613 if (PyErr_Occurred()) SWIG_fail;
30614 }
30615 resultobj = SWIG_Py_Void();
30616 return resultobj;
30617 fail:
30618 return NULL;
30619 }
30620
30621
30622 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30623 PyObject *resultobj = 0;
30624 wxWindow *arg1 = (wxWindow *) 0 ;
30625 wxRect *arg2 = 0 ;
30626 void *argp1 = 0 ;
30627 int res1 = 0 ;
30628 wxRect temp2 ;
30629 PyObject * obj0 = 0 ;
30630 PyObject * obj1 = 0 ;
30631 char * kwnames[] = {
30632 (char *) "self",(char *) "rect", NULL
30633 };
30634
30635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30637 if (!SWIG_IsOK(res1)) {
30638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30639 }
30640 arg1 = reinterpret_cast< wxWindow * >(argp1);
30641 {
30642 arg2 = &temp2;
30643 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30644 }
30645 {
30646 PyThreadState* __tstate = wxPyBeginAllowThreads();
30647 (arg1)->SetClientSize((wxRect const &)*arg2);
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 resultobj = SWIG_Py_Void();
30652 return resultobj;
30653 fail:
30654 return NULL;
30655 }
30656
30657
30658 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30659 PyObject *resultobj = 0;
30660 wxWindow *arg1 = (wxWindow *) 0 ;
30661 wxPoint result;
30662 void *argp1 = 0 ;
30663 int res1 = 0 ;
30664 PyObject *swig_obj[1] ;
30665
30666 if (!args) SWIG_fail;
30667 swig_obj[0] = args;
30668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30669 if (!SWIG_IsOK(res1)) {
30670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30671 }
30672 arg1 = reinterpret_cast< wxWindow * >(argp1);
30673 {
30674 PyThreadState* __tstate = wxPyBeginAllowThreads();
30675 result = ((wxWindow const *)arg1)->GetPosition();
30676 wxPyEndAllowThreads(__tstate);
30677 if (PyErr_Occurred()) SWIG_fail;
30678 }
30679 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30680 return resultobj;
30681 fail:
30682 return NULL;
30683 }
30684
30685
30686 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30687 PyObject *resultobj = 0;
30688 wxWindow *arg1 = (wxWindow *) 0 ;
30689 int *arg2 = (int *) 0 ;
30690 int *arg3 = (int *) 0 ;
30691 void *argp1 = 0 ;
30692 int res1 = 0 ;
30693 int temp2 ;
30694 int res2 = SWIG_TMPOBJ ;
30695 int temp3 ;
30696 int res3 = SWIG_TMPOBJ ;
30697 PyObject *swig_obj[1] ;
30698
30699 arg2 = &temp2;
30700 arg3 = &temp3;
30701 if (!args) SWIG_fail;
30702 swig_obj[0] = args;
30703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30704 if (!SWIG_IsOK(res1)) {
30705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30706 }
30707 arg1 = reinterpret_cast< wxWindow * >(argp1);
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 resultobj = SWIG_Py_Void();
30715 if (SWIG_IsTmpObj(res2)) {
30716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30717 } else {
30718 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30720 }
30721 if (SWIG_IsTmpObj(res3)) {
30722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30723 } else {
30724 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30726 }
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30734 PyObject *resultobj = 0;
30735 wxWindow *arg1 = (wxWindow *) 0 ;
30736 wxPoint result;
30737 void *argp1 = 0 ;
30738 int res1 = 0 ;
30739 PyObject *swig_obj[1] ;
30740
30741 if (!args) SWIG_fail;
30742 swig_obj[0] = args;
30743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30744 if (!SWIG_IsOK(res1)) {
30745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30746 }
30747 arg1 = reinterpret_cast< wxWindow * >(argp1);
30748 {
30749 PyThreadState* __tstate = wxPyBeginAllowThreads();
30750 result = ((wxWindow const *)arg1)->GetScreenPosition();
30751 wxPyEndAllowThreads(__tstate);
30752 if (PyErr_Occurred()) SWIG_fail;
30753 }
30754 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30755 return resultobj;
30756 fail:
30757 return NULL;
30758 }
30759
30760
30761 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30762 PyObject *resultobj = 0;
30763 wxWindow *arg1 = (wxWindow *) 0 ;
30764 int *arg2 = (int *) 0 ;
30765 int *arg3 = (int *) 0 ;
30766 void *argp1 = 0 ;
30767 int res1 = 0 ;
30768 int temp2 ;
30769 int res2 = SWIG_TMPOBJ ;
30770 int temp3 ;
30771 int res3 = SWIG_TMPOBJ ;
30772 PyObject *swig_obj[1] ;
30773
30774 arg2 = &temp2;
30775 arg3 = &temp3;
30776 if (!args) SWIG_fail;
30777 swig_obj[0] = args;
30778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30779 if (!SWIG_IsOK(res1)) {
30780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30781 }
30782 arg1 = reinterpret_cast< wxWindow * >(argp1);
30783 {
30784 PyThreadState* __tstate = wxPyBeginAllowThreads();
30785 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30786 wxPyEndAllowThreads(__tstate);
30787 if (PyErr_Occurred()) SWIG_fail;
30788 }
30789 resultobj = SWIG_Py_Void();
30790 if (SWIG_IsTmpObj(res2)) {
30791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30792 } else {
30793 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30795 }
30796 if (SWIG_IsTmpObj(res3)) {
30797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30798 } else {
30799 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30801 }
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30809 PyObject *resultobj = 0;
30810 wxWindow *arg1 = (wxWindow *) 0 ;
30811 wxRect result;
30812 void *argp1 = 0 ;
30813 int res1 = 0 ;
30814 PyObject *swig_obj[1] ;
30815
30816 if (!args) SWIG_fail;
30817 swig_obj[0] = args;
30818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30819 if (!SWIG_IsOK(res1)) {
30820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30821 }
30822 arg1 = reinterpret_cast< wxWindow * >(argp1);
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 result = ((wxWindow const *)arg1)->GetScreenRect();
30826 wxPyEndAllowThreads(__tstate);
30827 if (PyErr_Occurred()) SWIG_fail;
30828 }
30829 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30830 return resultobj;
30831 fail:
30832 return NULL;
30833 }
30834
30835
30836 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30837 PyObject *resultobj = 0;
30838 wxWindow *arg1 = (wxWindow *) 0 ;
30839 wxSize result;
30840 void *argp1 = 0 ;
30841 int res1 = 0 ;
30842 PyObject *swig_obj[1] ;
30843
30844 if (!args) SWIG_fail;
30845 swig_obj[0] = args;
30846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30847 if (!SWIG_IsOK(res1)) {
30848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30849 }
30850 arg1 = reinterpret_cast< wxWindow * >(argp1);
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = ((wxWindow const *)arg1)->GetSize();
30854 wxPyEndAllowThreads(__tstate);
30855 if (PyErr_Occurred()) SWIG_fail;
30856 }
30857 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30865 PyObject *resultobj = 0;
30866 wxWindow *arg1 = (wxWindow *) 0 ;
30867 int *arg2 = (int *) 0 ;
30868 int *arg3 = (int *) 0 ;
30869 void *argp1 = 0 ;
30870 int res1 = 0 ;
30871 int temp2 ;
30872 int res2 = SWIG_TMPOBJ ;
30873 int temp3 ;
30874 int res3 = SWIG_TMPOBJ ;
30875 PyObject *swig_obj[1] ;
30876
30877 arg2 = &temp2;
30878 arg3 = &temp3;
30879 if (!args) SWIG_fail;
30880 swig_obj[0] = args;
30881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30882 if (!SWIG_IsOK(res1)) {
30883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30884 }
30885 arg1 = reinterpret_cast< wxWindow * >(argp1);
30886 {
30887 PyThreadState* __tstate = wxPyBeginAllowThreads();
30888 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30889 wxPyEndAllowThreads(__tstate);
30890 if (PyErr_Occurred()) SWIG_fail;
30891 }
30892 resultobj = SWIG_Py_Void();
30893 if (SWIG_IsTmpObj(res2)) {
30894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30895 } else {
30896 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30898 }
30899 if (SWIG_IsTmpObj(res3)) {
30900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30901 } else {
30902 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30904 }
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30912 PyObject *resultobj = 0;
30913 wxWindow *arg1 = (wxWindow *) 0 ;
30914 wxRect result;
30915 void *argp1 = 0 ;
30916 int res1 = 0 ;
30917 PyObject *swig_obj[1] ;
30918
30919 if (!args) SWIG_fail;
30920 swig_obj[0] = args;
30921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30922 if (!SWIG_IsOK(res1)) {
30923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30924 }
30925 arg1 = reinterpret_cast< wxWindow * >(argp1);
30926 {
30927 PyThreadState* __tstate = wxPyBeginAllowThreads();
30928 result = ((wxWindow const *)arg1)->GetRect();
30929 wxPyEndAllowThreads(__tstate);
30930 if (PyErr_Occurred()) SWIG_fail;
30931 }
30932 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30933 return resultobj;
30934 fail:
30935 return NULL;
30936 }
30937
30938
30939 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30940 PyObject *resultobj = 0;
30941 wxWindow *arg1 = (wxWindow *) 0 ;
30942 wxSize result;
30943 void *argp1 = 0 ;
30944 int res1 = 0 ;
30945 PyObject *swig_obj[1] ;
30946
30947 if (!args) SWIG_fail;
30948 swig_obj[0] = args;
30949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30950 if (!SWIG_IsOK(res1)) {
30951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30952 }
30953 arg1 = reinterpret_cast< wxWindow * >(argp1);
30954 {
30955 PyThreadState* __tstate = wxPyBeginAllowThreads();
30956 result = ((wxWindow const *)arg1)->GetClientSize();
30957 wxPyEndAllowThreads(__tstate);
30958 if (PyErr_Occurred()) SWIG_fail;
30959 }
30960 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30961 return resultobj;
30962 fail:
30963 return NULL;
30964 }
30965
30966
30967 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30968 PyObject *resultobj = 0;
30969 wxWindow *arg1 = (wxWindow *) 0 ;
30970 int *arg2 = (int *) 0 ;
30971 int *arg3 = (int *) 0 ;
30972 void *argp1 = 0 ;
30973 int res1 = 0 ;
30974 int temp2 ;
30975 int res2 = SWIG_TMPOBJ ;
30976 int temp3 ;
30977 int res3 = SWIG_TMPOBJ ;
30978 PyObject *swig_obj[1] ;
30979
30980 arg2 = &temp2;
30981 arg3 = &temp3;
30982 if (!args) SWIG_fail;
30983 swig_obj[0] = args;
30984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30985 if (!SWIG_IsOK(res1)) {
30986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30987 }
30988 arg1 = reinterpret_cast< wxWindow * >(argp1);
30989 {
30990 PyThreadState* __tstate = wxPyBeginAllowThreads();
30991 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30992 wxPyEndAllowThreads(__tstate);
30993 if (PyErr_Occurred()) SWIG_fail;
30994 }
30995 resultobj = SWIG_Py_Void();
30996 if (SWIG_IsTmpObj(res2)) {
30997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30998 } else {
30999 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31001 }
31002 if (SWIG_IsTmpObj(res3)) {
31003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31004 } else {
31005 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31007 }
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31015 PyObject *resultobj = 0;
31016 wxWindow *arg1 = (wxWindow *) 0 ;
31017 wxPoint result;
31018 void *argp1 = 0 ;
31019 int res1 = 0 ;
31020 PyObject *swig_obj[1] ;
31021
31022 if (!args) SWIG_fail;
31023 swig_obj[0] = args;
31024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31025 if (!SWIG_IsOK(res1)) {
31026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31027 }
31028 arg1 = reinterpret_cast< wxWindow * >(argp1);
31029 {
31030 PyThreadState* __tstate = wxPyBeginAllowThreads();
31031 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31032 wxPyEndAllowThreads(__tstate);
31033 if (PyErr_Occurred()) SWIG_fail;
31034 }
31035 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31036 return resultobj;
31037 fail:
31038 return NULL;
31039 }
31040
31041
31042 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31043 PyObject *resultobj = 0;
31044 wxWindow *arg1 = (wxWindow *) 0 ;
31045 wxRect result;
31046 void *argp1 = 0 ;
31047 int res1 = 0 ;
31048 PyObject *swig_obj[1] ;
31049
31050 if (!args) SWIG_fail;
31051 swig_obj[0] = args;
31052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31053 if (!SWIG_IsOK(res1)) {
31054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31055 }
31056 arg1 = reinterpret_cast< wxWindow * >(argp1);
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 result = ((wxWindow const *)arg1)->GetClientRect();
31060 wxPyEndAllowThreads(__tstate);
31061 if (PyErr_Occurred()) SWIG_fail;
31062 }
31063 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31064 return resultobj;
31065 fail:
31066 return NULL;
31067 }
31068
31069
31070 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31071 PyObject *resultobj = 0;
31072 wxWindow *arg1 = (wxWindow *) 0 ;
31073 wxSize result;
31074 void *argp1 = 0 ;
31075 int res1 = 0 ;
31076 PyObject *swig_obj[1] ;
31077
31078 if (!args) SWIG_fail;
31079 swig_obj[0] = args;
31080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31081 if (!SWIG_IsOK(res1)) {
31082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31083 }
31084 arg1 = reinterpret_cast< wxWindow * >(argp1);
31085 {
31086 PyThreadState* __tstate = wxPyBeginAllowThreads();
31087 result = ((wxWindow const *)arg1)->GetBestSize();
31088 wxPyEndAllowThreads(__tstate);
31089 if (PyErr_Occurred()) SWIG_fail;
31090 }
31091 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31092 return resultobj;
31093 fail:
31094 return NULL;
31095 }
31096
31097
31098 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31099 PyObject *resultobj = 0;
31100 wxWindow *arg1 = (wxWindow *) 0 ;
31101 int *arg2 = (int *) 0 ;
31102 int *arg3 = (int *) 0 ;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 int temp2 ;
31106 int res2 = SWIG_TMPOBJ ;
31107 int temp3 ;
31108 int res3 = SWIG_TMPOBJ ;
31109 PyObject *swig_obj[1] ;
31110
31111 arg2 = &temp2;
31112 arg3 = &temp3;
31113 if (!args) SWIG_fail;
31114 swig_obj[0] = args;
31115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31116 if (!SWIG_IsOK(res1)) {
31117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31118 }
31119 arg1 = reinterpret_cast< wxWindow * >(argp1);
31120 {
31121 PyThreadState* __tstate = wxPyBeginAllowThreads();
31122 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31123 wxPyEndAllowThreads(__tstate);
31124 if (PyErr_Occurred()) SWIG_fail;
31125 }
31126 resultobj = SWIG_Py_Void();
31127 if (SWIG_IsTmpObj(res2)) {
31128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31129 } else {
31130 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31132 }
31133 if (SWIG_IsTmpObj(res3)) {
31134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31135 } else {
31136 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31138 }
31139 return resultobj;
31140 fail:
31141 return NULL;
31142 }
31143
31144
31145 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31146 PyObject *resultobj = 0;
31147 wxWindow *arg1 = (wxWindow *) 0 ;
31148 void *argp1 = 0 ;
31149 int res1 = 0 ;
31150 PyObject *swig_obj[1] ;
31151
31152 if (!args) SWIG_fail;
31153 swig_obj[0] = args;
31154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31155 if (!SWIG_IsOK(res1)) {
31156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31157 }
31158 arg1 = reinterpret_cast< wxWindow * >(argp1);
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 (arg1)->InvalidateBestSize();
31162 wxPyEndAllowThreads(__tstate);
31163 if (PyErr_Occurred()) SWIG_fail;
31164 }
31165 resultobj = SWIG_Py_Void();
31166 return resultobj;
31167 fail:
31168 return NULL;
31169 }
31170
31171
31172 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31173 PyObject *resultobj = 0;
31174 wxWindow *arg1 = (wxWindow *) 0 ;
31175 wxSize *arg2 = 0 ;
31176 void *argp1 = 0 ;
31177 int res1 = 0 ;
31178 wxSize temp2 ;
31179 PyObject * obj0 = 0 ;
31180 PyObject * obj1 = 0 ;
31181 char * kwnames[] = {
31182 (char *) "self",(char *) "size", NULL
31183 };
31184
31185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31187 if (!SWIG_IsOK(res1)) {
31188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31189 }
31190 arg1 = reinterpret_cast< wxWindow * >(argp1);
31191 {
31192 arg2 = &temp2;
31193 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31194 }
31195 {
31196 PyThreadState* __tstate = wxPyBeginAllowThreads();
31197 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31198 wxPyEndAllowThreads(__tstate);
31199 if (PyErr_Occurred()) SWIG_fail;
31200 }
31201 resultobj = SWIG_Py_Void();
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31209 PyObject *resultobj = 0;
31210 wxWindow *arg1 = (wxWindow *) 0 ;
31211 wxSize result;
31212 void *argp1 = 0 ;
31213 int res1 = 0 ;
31214 PyObject *swig_obj[1] ;
31215
31216 if (!args) SWIG_fail;
31217 swig_obj[0] = args;
31218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31219 if (!SWIG_IsOK(res1)) {
31220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31221 }
31222 arg1 = reinterpret_cast< wxWindow * >(argp1);
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31226 wxPyEndAllowThreads(__tstate);
31227 if (PyErr_Occurred()) SWIG_fail;
31228 }
31229 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31237 PyObject *resultobj = 0;
31238 wxWindow *arg1 = (wxWindow *) 0 ;
31239 wxSize result;
31240 void *argp1 = 0 ;
31241 int res1 = 0 ;
31242 PyObject *swig_obj[1] ;
31243
31244 if (!args) SWIG_fail;
31245 swig_obj[0] = args;
31246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31247 if (!SWIG_IsOK(res1)) {
31248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31249 }
31250 arg1 = reinterpret_cast< wxWindow * >(argp1);
31251 {
31252 PyThreadState* __tstate = wxPyBeginAllowThreads();
31253 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31254 wxPyEndAllowThreads(__tstate);
31255 if (PyErr_Occurred()) SWIG_fail;
31256 }
31257 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31258 return resultobj;
31259 fail:
31260 return NULL;
31261 }
31262
31263
31264 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31265 PyObject *resultobj = 0;
31266 wxWindow *arg1 = (wxWindow *) 0 ;
31267 int arg2 = (int) wxBOTH ;
31268 void *argp1 = 0 ;
31269 int res1 = 0 ;
31270 int val2 ;
31271 int ecode2 = 0 ;
31272 PyObject * obj0 = 0 ;
31273 PyObject * obj1 = 0 ;
31274 char * kwnames[] = {
31275 (char *) "self",(char *) "direction", NULL
31276 };
31277
31278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31280 if (!SWIG_IsOK(res1)) {
31281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31282 }
31283 arg1 = reinterpret_cast< wxWindow * >(argp1);
31284 if (obj1) {
31285 ecode2 = SWIG_AsVal_int(obj1, &val2);
31286 if (!SWIG_IsOK(ecode2)) {
31287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31288 }
31289 arg2 = static_cast< int >(val2);
31290 }
31291 {
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 (arg1)->Center(arg2);
31294 wxPyEndAllowThreads(__tstate);
31295 if (PyErr_Occurred()) SWIG_fail;
31296 }
31297 resultobj = SWIG_Py_Void();
31298 return resultobj;
31299 fail:
31300 return NULL;
31301 }
31302
31303
31304 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31305 PyObject *resultobj = 0;
31306 wxWindow *arg1 = (wxWindow *) 0 ;
31307 int arg2 = (int) wxBOTH ;
31308 void *argp1 = 0 ;
31309 int res1 = 0 ;
31310 int val2 ;
31311 int ecode2 = 0 ;
31312 PyObject * obj0 = 0 ;
31313 PyObject * obj1 = 0 ;
31314 char * kwnames[] = {
31315 (char *) "self",(char *) "dir", NULL
31316 };
31317
31318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31320 if (!SWIG_IsOK(res1)) {
31321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31322 }
31323 arg1 = reinterpret_cast< wxWindow * >(argp1);
31324 if (obj1) {
31325 ecode2 = SWIG_AsVal_int(obj1, &val2);
31326 if (!SWIG_IsOK(ecode2)) {
31327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31328 }
31329 arg2 = static_cast< int >(val2);
31330 }
31331 {
31332 PyThreadState* __tstate = wxPyBeginAllowThreads();
31333 (arg1)->CenterOnParent(arg2);
31334 wxPyEndAllowThreads(__tstate);
31335 if (PyErr_Occurred()) SWIG_fail;
31336 }
31337 resultobj = SWIG_Py_Void();
31338 return resultobj;
31339 fail:
31340 return NULL;
31341 }
31342
31343
31344 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31345 PyObject *resultobj = 0;
31346 wxWindow *arg1 = (wxWindow *) 0 ;
31347 void *argp1 = 0 ;
31348 int res1 = 0 ;
31349 PyObject *swig_obj[1] ;
31350
31351 if (!args) SWIG_fail;
31352 swig_obj[0] = args;
31353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31354 if (!SWIG_IsOK(res1)) {
31355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31356 }
31357 arg1 = reinterpret_cast< wxWindow * >(argp1);
31358 {
31359 PyThreadState* __tstate = wxPyBeginAllowThreads();
31360 (arg1)->Fit();
31361 wxPyEndAllowThreads(__tstate);
31362 if (PyErr_Occurred()) SWIG_fail;
31363 }
31364 resultobj = SWIG_Py_Void();
31365 return resultobj;
31366 fail:
31367 return NULL;
31368 }
31369
31370
31371 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31372 PyObject *resultobj = 0;
31373 wxWindow *arg1 = (wxWindow *) 0 ;
31374 void *argp1 = 0 ;
31375 int res1 = 0 ;
31376 PyObject *swig_obj[1] ;
31377
31378 if (!args) SWIG_fail;
31379 swig_obj[0] = args;
31380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31381 if (!SWIG_IsOK(res1)) {
31382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31383 }
31384 arg1 = reinterpret_cast< wxWindow * >(argp1);
31385 {
31386 PyThreadState* __tstate = wxPyBeginAllowThreads();
31387 (arg1)->FitInside();
31388 wxPyEndAllowThreads(__tstate);
31389 if (PyErr_Occurred()) SWIG_fail;
31390 }
31391 resultobj = SWIG_Py_Void();
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31399 PyObject *resultobj = 0;
31400 wxWindow *arg1 = (wxWindow *) 0 ;
31401 int arg2 ;
31402 int arg3 ;
31403 int arg4 = (int) -1 ;
31404 int arg5 = (int) -1 ;
31405 int arg6 = (int) -1 ;
31406 int arg7 = (int) -1 ;
31407 void *argp1 = 0 ;
31408 int res1 = 0 ;
31409 int val2 ;
31410 int ecode2 = 0 ;
31411 int val3 ;
31412 int ecode3 = 0 ;
31413 int val4 ;
31414 int ecode4 = 0 ;
31415 int val5 ;
31416 int ecode5 = 0 ;
31417 int val6 ;
31418 int ecode6 = 0 ;
31419 int val7 ;
31420 int ecode7 = 0 ;
31421 PyObject * obj0 = 0 ;
31422 PyObject * obj1 = 0 ;
31423 PyObject * obj2 = 0 ;
31424 PyObject * obj3 = 0 ;
31425 PyObject * obj4 = 0 ;
31426 PyObject * obj5 = 0 ;
31427 PyObject * obj6 = 0 ;
31428 char * kwnames[] = {
31429 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31430 };
31431
31432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31434 if (!SWIG_IsOK(res1)) {
31435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31436 }
31437 arg1 = reinterpret_cast< wxWindow * >(argp1);
31438 ecode2 = SWIG_AsVal_int(obj1, &val2);
31439 if (!SWIG_IsOK(ecode2)) {
31440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31441 }
31442 arg2 = static_cast< int >(val2);
31443 ecode3 = SWIG_AsVal_int(obj2, &val3);
31444 if (!SWIG_IsOK(ecode3)) {
31445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31446 }
31447 arg3 = static_cast< int >(val3);
31448 if (obj3) {
31449 ecode4 = SWIG_AsVal_int(obj3, &val4);
31450 if (!SWIG_IsOK(ecode4)) {
31451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31452 }
31453 arg4 = static_cast< int >(val4);
31454 }
31455 if (obj4) {
31456 ecode5 = SWIG_AsVal_int(obj4, &val5);
31457 if (!SWIG_IsOK(ecode5)) {
31458 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31459 }
31460 arg5 = static_cast< int >(val5);
31461 }
31462 if (obj5) {
31463 ecode6 = SWIG_AsVal_int(obj5, &val6);
31464 if (!SWIG_IsOK(ecode6)) {
31465 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31466 }
31467 arg6 = static_cast< int >(val6);
31468 }
31469 if (obj6) {
31470 ecode7 = SWIG_AsVal_int(obj6, &val7);
31471 if (!SWIG_IsOK(ecode7)) {
31472 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31473 }
31474 arg7 = static_cast< int >(val7);
31475 }
31476 {
31477 PyThreadState* __tstate = wxPyBeginAllowThreads();
31478 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 resultobj = SWIG_Py_Void();
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31490 PyObject *resultobj = 0;
31491 wxWindow *arg1 = (wxWindow *) 0 ;
31492 wxSize *arg2 = 0 ;
31493 wxSize const &arg3_defvalue = wxDefaultSize ;
31494 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31495 wxSize const &arg4_defvalue = wxDefaultSize ;
31496 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31497 void *argp1 = 0 ;
31498 int res1 = 0 ;
31499 wxSize temp2 ;
31500 wxSize temp3 ;
31501 wxSize temp4 ;
31502 PyObject * obj0 = 0 ;
31503 PyObject * obj1 = 0 ;
31504 PyObject * obj2 = 0 ;
31505 PyObject * obj3 = 0 ;
31506 char * kwnames[] = {
31507 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31508 };
31509
31510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31512 if (!SWIG_IsOK(res1)) {
31513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31514 }
31515 arg1 = reinterpret_cast< wxWindow * >(argp1);
31516 {
31517 arg2 = &temp2;
31518 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31519 }
31520 if (obj2) {
31521 {
31522 arg3 = &temp3;
31523 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31524 }
31525 }
31526 if (obj3) {
31527 {
31528 arg4 = &temp4;
31529 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31530 }
31531 }
31532 {
31533 PyThreadState* __tstate = wxPyBeginAllowThreads();
31534 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 resultobj = SWIG_Py_Void();
31539 return resultobj;
31540 fail:
31541 return NULL;
31542 }
31543
31544
31545 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31546 PyObject *resultobj = 0;
31547 wxWindow *arg1 = (wxWindow *) 0 ;
31548 int arg2 ;
31549 int arg3 ;
31550 int arg4 = (int) -1 ;
31551 int arg5 = (int) -1 ;
31552 void *argp1 = 0 ;
31553 int res1 = 0 ;
31554 int val2 ;
31555 int ecode2 = 0 ;
31556 int val3 ;
31557 int ecode3 = 0 ;
31558 int val4 ;
31559 int ecode4 = 0 ;
31560 int val5 ;
31561 int ecode5 = 0 ;
31562 PyObject * obj0 = 0 ;
31563 PyObject * obj1 = 0 ;
31564 PyObject * obj2 = 0 ;
31565 PyObject * obj3 = 0 ;
31566 PyObject * obj4 = 0 ;
31567 char * kwnames[] = {
31568 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31569 };
31570
31571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31573 if (!SWIG_IsOK(res1)) {
31574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31575 }
31576 arg1 = reinterpret_cast< wxWindow * >(argp1);
31577 ecode2 = SWIG_AsVal_int(obj1, &val2);
31578 if (!SWIG_IsOK(ecode2)) {
31579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31580 }
31581 arg2 = static_cast< int >(val2);
31582 ecode3 = SWIG_AsVal_int(obj2, &val3);
31583 if (!SWIG_IsOK(ecode3)) {
31584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31585 }
31586 arg3 = static_cast< int >(val3);
31587 if (obj3) {
31588 ecode4 = SWIG_AsVal_int(obj3, &val4);
31589 if (!SWIG_IsOK(ecode4)) {
31590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31591 }
31592 arg4 = static_cast< int >(val4);
31593 }
31594 if (obj4) {
31595 ecode5 = SWIG_AsVal_int(obj4, &val5);
31596 if (!SWIG_IsOK(ecode5)) {
31597 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31598 }
31599 arg5 = static_cast< int >(val5);
31600 }
31601 {
31602 PyThreadState* __tstate = wxPyBeginAllowThreads();
31603 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31604 wxPyEndAllowThreads(__tstate);
31605 if (PyErr_Occurred()) SWIG_fail;
31606 }
31607 resultobj = SWIG_Py_Void();
31608 return resultobj;
31609 fail:
31610 return NULL;
31611 }
31612
31613
31614 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31615 PyObject *resultobj = 0;
31616 wxWindow *arg1 = (wxWindow *) 0 ;
31617 wxSize *arg2 = 0 ;
31618 wxSize const &arg3_defvalue = wxDefaultSize ;
31619 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31620 void *argp1 = 0 ;
31621 int res1 = 0 ;
31622 wxSize temp2 ;
31623 wxSize temp3 ;
31624 PyObject * obj0 = 0 ;
31625 PyObject * obj1 = 0 ;
31626 PyObject * obj2 = 0 ;
31627 char * kwnames[] = {
31628 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31629 };
31630
31631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31633 if (!SWIG_IsOK(res1)) {
31634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31635 }
31636 arg1 = reinterpret_cast< wxWindow * >(argp1);
31637 {
31638 arg2 = &temp2;
31639 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31640 }
31641 if (obj2) {
31642 {
31643 arg3 = &temp3;
31644 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31645 }
31646 }
31647 {
31648 PyThreadState* __tstate = wxPyBeginAllowThreads();
31649 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31650 wxPyEndAllowThreads(__tstate);
31651 if (PyErr_Occurred()) SWIG_fail;
31652 }
31653 resultobj = SWIG_Py_Void();
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31661 PyObject *resultobj = 0;
31662 wxWindow *arg1 = (wxWindow *) 0 ;
31663 wxSize result;
31664 void *argp1 = 0 ;
31665 int res1 = 0 ;
31666 PyObject *swig_obj[1] ;
31667
31668 if (!args) SWIG_fail;
31669 swig_obj[0] = args;
31670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31671 if (!SWIG_IsOK(res1)) {
31672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31673 }
31674 arg1 = reinterpret_cast< wxWindow * >(argp1);
31675 {
31676 PyThreadState* __tstate = wxPyBeginAllowThreads();
31677 result = ((wxWindow const *)arg1)->GetMaxSize();
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31682 return resultobj;
31683 fail:
31684 return NULL;
31685 }
31686
31687
31688 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31689 PyObject *resultobj = 0;
31690 wxWindow *arg1 = (wxWindow *) 0 ;
31691 wxSize result;
31692 void *argp1 = 0 ;
31693 int res1 = 0 ;
31694 PyObject *swig_obj[1] ;
31695
31696 if (!args) SWIG_fail;
31697 swig_obj[0] = args;
31698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31699 if (!SWIG_IsOK(res1)) {
31700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31701 }
31702 arg1 = reinterpret_cast< wxWindow * >(argp1);
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 result = ((wxWindow const *)arg1)->GetMinSize();
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj = 0;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 wxSize *arg2 = 0 ;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 wxSize temp2 ;
31723 PyObject * obj0 = 0 ;
31724 PyObject * obj1 = 0 ;
31725 char * kwnames[] = {
31726 (char *) "self",(char *) "minSize", NULL
31727 };
31728
31729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31731 if (!SWIG_IsOK(res1)) {
31732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31733 }
31734 arg1 = reinterpret_cast< wxWindow * >(argp1);
31735 {
31736 arg2 = &temp2;
31737 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31738 }
31739 {
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 (arg1)->SetMinSize((wxSize const &)*arg2);
31742 wxPyEndAllowThreads(__tstate);
31743 if (PyErr_Occurred()) SWIG_fail;
31744 }
31745 resultobj = SWIG_Py_Void();
31746 return resultobj;
31747 fail:
31748 return NULL;
31749 }
31750
31751
31752 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31753 PyObject *resultobj = 0;
31754 wxWindow *arg1 = (wxWindow *) 0 ;
31755 wxSize *arg2 = 0 ;
31756 void *argp1 = 0 ;
31757 int res1 = 0 ;
31758 wxSize temp2 ;
31759 PyObject * obj0 = 0 ;
31760 PyObject * obj1 = 0 ;
31761 char * kwnames[] = {
31762 (char *) "self",(char *) "maxSize", NULL
31763 };
31764
31765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31767 if (!SWIG_IsOK(res1)) {
31768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31769 }
31770 arg1 = reinterpret_cast< wxWindow * >(argp1);
31771 {
31772 arg2 = &temp2;
31773 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31774 }
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 (arg1)->SetMaxSize((wxSize const &)*arg2);
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_Py_Void();
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31789 PyObject *resultobj = 0;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 int result;
31792 void *argp1 = 0 ;
31793 int res1 = 0 ;
31794 PyObject *swig_obj[1] ;
31795
31796 if (!args) SWIG_fail;
31797 swig_obj[0] = args;
31798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31799 if (!SWIG_IsOK(res1)) {
31800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31801 }
31802 arg1 = reinterpret_cast< wxWindow * >(argp1);
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 resultobj = SWIG_From_int(static_cast< int >(result));
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31817 PyObject *resultobj = 0;
31818 wxWindow *arg1 = (wxWindow *) 0 ;
31819 int result;
31820 void *argp1 = 0 ;
31821 int res1 = 0 ;
31822 PyObject *swig_obj[1] ;
31823
31824 if (!args) SWIG_fail;
31825 swig_obj[0] = args;
31826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31827 if (!SWIG_IsOK(res1)) {
31828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31829 }
31830 arg1 = reinterpret_cast< wxWindow * >(argp1);
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31834 wxPyEndAllowThreads(__tstate);
31835 if (PyErr_Occurred()) SWIG_fail;
31836 }
31837 resultobj = SWIG_From_int(static_cast< int >(result));
31838 return resultobj;
31839 fail:
31840 return NULL;
31841 }
31842
31843
31844 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31845 PyObject *resultobj = 0;
31846 wxWindow *arg1 = (wxWindow *) 0 ;
31847 int result;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 PyObject *swig_obj[1] ;
31851
31852 if (!args) SWIG_fail;
31853 swig_obj[0] = args;
31854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31855 if (!SWIG_IsOK(res1)) {
31856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31857 }
31858 arg1 = reinterpret_cast< wxWindow * >(argp1);
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31862 wxPyEndAllowThreads(__tstate);
31863 if (PyErr_Occurred()) SWIG_fail;
31864 }
31865 resultobj = SWIG_From_int(static_cast< int >(result));
31866 return resultobj;
31867 fail:
31868 return NULL;
31869 }
31870
31871
31872 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31873 PyObject *resultobj = 0;
31874 wxWindow *arg1 = (wxWindow *) 0 ;
31875 int result;
31876 void *argp1 = 0 ;
31877 int res1 = 0 ;
31878 PyObject *swig_obj[1] ;
31879
31880 if (!args) SWIG_fail;
31881 swig_obj[0] = args;
31882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31883 if (!SWIG_IsOK(res1)) {
31884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31885 }
31886 arg1 = reinterpret_cast< wxWindow * >(argp1);
31887 {
31888 PyThreadState* __tstate = wxPyBeginAllowThreads();
31889 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31890 wxPyEndAllowThreads(__tstate);
31891 if (PyErr_Occurred()) SWIG_fail;
31892 }
31893 resultobj = SWIG_From_int(static_cast< int >(result));
31894 return resultobj;
31895 fail:
31896 return NULL;
31897 }
31898
31899
31900 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31901 PyObject *resultobj = 0;
31902 wxWindow *arg1 = (wxWindow *) 0 ;
31903 wxSize *arg2 = 0 ;
31904 void *argp1 = 0 ;
31905 int res1 = 0 ;
31906 wxSize temp2 ;
31907 PyObject * obj0 = 0 ;
31908 PyObject * obj1 = 0 ;
31909 char * kwnames[] = {
31910 (char *) "self",(char *) "size", NULL
31911 };
31912
31913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31915 if (!SWIG_IsOK(res1)) {
31916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31917 }
31918 arg1 = reinterpret_cast< wxWindow * >(argp1);
31919 {
31920 arg2 = &temp2;
31921 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31922 }
31923 {
31924 PyThreadState* __tstate = wxPyBeginAllowThreads();
31925 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31926 wxPyEndAllowThreads(__tstate);
31927 if (PyErr_Occurred()) SWIG_fail;
31928 }
31929 resultobj = SWIG_Py_Void();
31930 return resultobj;
31931 fail:
31932 return NULL;
31933 }
31934
31935
31936 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31937 PyObject *resultobj = 0;
31938 wxWindow *arg1 = (wxWindow *) 0 ;
31939 int arg2 ;
31940 int arg3 ;
31941 void *argp1 = 0 ;
31942 int res1 = 0 ;
31943 int val2 ;
31944 int ecode2 = 0 ;
31945 int val3 ;
31946 int ecode3 = 0 ;
31947 PyObject * obj0 = 0 ;
31948 PyObject * obj1 = 0 ;
31949 PyObject * obj2 = 0 ;
31950 char * kwnames[] = {
31951 (char *) "self",(char *) "w",(char *) "h", NULL
31952 };
31953
31954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31958 }
31959 arg1 = reinterpret_cast< wxWindow * >(argp1);
31960 ecode2 = SWIG_AsVal_int(obj1, &val2);
31961 if (!SWIG_IsOK(ecode2)) {
31962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31963 }
31964 arg2 = static_cast< int >(val2);
31965 ecode3 = SWIG_AsVal_int(obj2, &val3);
31966 if (!SWIG_IsOK(ecode3)) {
31967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31968 }
31969 arg3 = static_cast< int >(val3);
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 (arg1)->SetVirtualSize(arg2,arg3);
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 resultobj = SWIG_Py_Void();
31977 return resultobj;
31978 fail:
31979 return NULL;
31980 }
31981
31982
31983 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31984 PyObject *resultobj = 0;
31985 wxWindow *arg1 = (wxWindow *) 0 ;
31986 wxSize result;
31987 void *argp1 = 0 ;
31988 int res1 = 0 ;
31989 PyObject *swig_obj[1] ;
31990
31991 if (!args) SWIG_fail;
31992 swig_obj[0] = args;
31993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31994 if (!SWIG_IsOK(res1)) {
31995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31996 }
31997 arg1 = reinterpret_cast< wxWindow * >(argp1);
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 result = ((wxWindow const *)arg1)->GetVirtualSize();
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32012 PyObject *resultobj = 0;
32013 wxWindow *arg1 = (wxWindow *) 0 ;
32014 int *arg2 = (int *) 0 ;
32015 int *arg3 = (int *) 0 ;
32016 void *argp1 = 0 ;
32017 int res1 = 0 ;
32018 int temp2 ;
32019 int res2 = SWIG_TMPOBJ ;
32020 int temp3 ;
32021 int res3 = SWIG_TMPOBJ ;
32022 PyObject *swig_obj[1] ;
32023
32024 arg2 = &temp2;
32025 arg3 = &temp3;
32026 if (!args) SWIG_fail;
32027 swig_obj[0] = args;
32028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32029 if (!SWIG_IsOK(res1)) {
32030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32031 }
32032 arg1 = reinterpret_cast< wxWindow * >(argp1);
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32036 wxPyEndAllowThreads(__tstate);
32037 if (PyErr_Occurred()) SWIG_fail;
32038 }
32039 resultobj = SWIG_Py_Void();
32040 if (SWIG_IsTmpObj(res2)) {
32041 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32042 } else {
32043 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32045 }
32046 if (SWIG_IsTmpObj(res3)) {
32047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32048 } else {
32049 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32051 }
32052 return resultobj;
32053 fail:
32054 return NULL;
32055 }
32056
32057
32058 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32059 PyObject *resultobj = 0;
32060 wxWindow *arg1 = (wxWindow *) 0 ;
32061 wxSize result;
32062 void *argp1 = 0 ;
32063 int res1 = 0 ;
32064 PyObject *swig_obj[1] ;
32065
32066 if (!args) SWIG_fail;
32067 swig_obj[0] = args;
32068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32069 if (!SWIG_IsOK(res1)) {
32070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32071 }
32072 arg1 = reinterpret_cast< wxWindow * >(argp1);
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32087 PyObject *resultobj = 0;
32088 wxWindow *arg1 = (wxWindow *) 0 ;
32089 bool arg2 = (bool) true ;
32090 bool result;
32091 void *argp1 = 0 ;
32092 int res1 = 0 ;
32093 bool val2 ;
32094 int ecode2 = 0 ;
32095 PyObject * obj0 = 0 ;
32096 PyObject * obj1 = 0 ;
32097 char * kwnames[] = {
32098 (char *) "self",(char *) "show", NULL
32099 };
32100
32101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32103 if (!SWIG_IsOK(res1)) {
32104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32105 }
32106 arg1 = reinterpret_cast< wxWindow * >(argp1);
32107 if (obj1) {
32108 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32109 if (!SWIG_IsOK(ecode2)) {
32110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32111 }
32112 arg2 = static_cast< bool >(val2);
32113 }
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = (bool)(arg1)->Show(arg2);
32117 wxPyEndAllowThreads(__tstate);
32118 if (PyErr_Occurred()) SWIG_fail;
32119 }
32120 {
32121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32122 }
32123 return resultobj;
32124 fail:
32125 return NULL;
32126 }
32127
32128
32129 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32130 PyObject *resultobj = 0;
32131 wxWindow *arg1 = (wxWindow *) 0 ;
32132 bool result;
32133 void *argp1 = 0 ;
32134 int res1 = 0 ;
32135 PyObject *swig_obj[1] ;
32136
32137 if (!args) SWIG_fail;
32138 swig_obj[0] = args;
32139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32140 if (!SWIG_IsOK(res1)) {
32141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32142 }
32143 arg1 = reinterpret_cast< wxWindow * >(argp1);
32144 {
32145 PyThreadState* __tstate = wxPyBeginAllowThreads();
32146 result = (bool)(arg1)->Hide();
32147 wxPyEndAllowThreads(__tstate);
32148 if (PyErr_Occurred()) SWIG_fail;
32149 }
32150 {
32151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32152 }
32153 return resultobj;
32154 fail:
32155 return NULL;
32156 }
32157
32158
32159 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32160 PyObject *resultobj = 0;
32161 wxWindow *arg1 = (wxWindow *) 0 ;
32162 bool arg2 = (bool) true ;
32163 bool result;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 bool val2 ;
32167 int ecode2 = 0 ;
32168 PyObject * obj0 = 0 ;
32169 PyObject * obj1 = 0 ;
32170 char * kwnames[] = {
32171 (char *) "self",(char *) "enable", NULL
32172 };
32173
32174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32176 if (!SWIG_IsOK(res1)) {
32177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32178 }
32179 arg1 = reinterpret_cast< wxWindow * >(argp1);
32180 if (obj1) {
32181 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32182 if (!SWIG_IsOK(ecode2)) {
32183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32184 }
32185 arg2 = static_cast< bool >(val2);
32186 }
32187 {
32188 PyThreadState* __tstate = wxPyBeginAllowThreads();
32189 result = (bool)(arg1)->Enable(arg2);
32190 wxPyEndAllowThreads(__tstate);
32191 if (PyErr_Occurred()) SWIG_fail;
32192 }
32193 {
32194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32195 }
32196 return resultobj;
32197 fail:
32198 return NULL;
32199 }
32200
32201
32202 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32203 PyObject *resultobj = 0;
32204 wxWindow *arg1 = (wxWindow *) 0 ;
32205 bool result;
32206 void *argp1 = 0 ;
32207 int res1 = 0 ;
32208 PyObject *swig_obj[1] ;
32209
32210 if (!args) SWIG_fail;
32211 swig_obj[0] = args;
32212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32213 if (!SWIG_IsOK(res1)) {
32214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32215 }
32216 arg1 = reinterpret_cast< wxWindow * >(argp1);
32217 {
32218 PyThreadState* __tstate = wxPyBeginAllowThreads();
32219 result = (bool)(arg1)->Disable();
32220 wxPyEndAllowThreads(__tstate);
32221 if (PyErr_Occurred()) SWIG_fail;
32222 }
32223 {
32224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32225 }
32226 return resultobj;
32227 fail:
32228 return NULL;
32229 }
32230
32231
32232 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32233 PyObject *resultobj = 0;
32234 wxWindow *arg1 = (wxWindow *) 0 ;
32235 bool result;
32236 void *argp1 = 0 ;
32237 int res1 = 0 ;
32238 PyObject *swig_obj[1] ;
32239
32240 if (!args) SWIG_fail;
32241 swig_obj[0] = args;
32242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32243 if (!SWIG_IsOK(res1)) {
32244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32245 }
32246 arg1 = reinterpret_cast< wxWindow * >(argp1);
32247 {
32248 PyThreadState* __tstate = wxPyBeginAllowThreads();
32249 result = (bool)((wxWindow const *)arg1)->IsShown();
32250 wxPyEndAllowThreads(__tstate);
32251 if (PyErr_Occurred()) SWIG_fail;
32252 }
32253 {
32254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32255 }
32256 return resultobj;
32257 fail:
32258 return NULL;
32259 }
32260
32261
32262 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32263 PyObject *resultobj = 0;
32264 wxWindow *arg1 = (wxWindow *) 0 ;
32265 bool result;
32266 void *argp1 = 0 ;
32267 int res1 = 0 ;
32268 PyObject *swig_obj[1] ;
32269
32270 if (!args) SWIG_fail;
32271 swig_obj[0] = args;
32272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32273 if (!SWIG_IsOK(res1)) {
32274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32275 }
32276 arg1 = reinterpret_cast< wxWindow * >(argp1);
32277 {
32278 PyThreadState* __tstate = wxPyBeginAllowThreads();
32279 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32285 }
32286 return resultobj;
32287 fail:
32288 return NULL;
32289 }
32290
32291
32292 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32293 PyObject *resultobj = 0;
32294 wxWindow *arg1 = (wxWindow *) 0 ;
32295 long arg2 ;
32296 void *argp1 = 0 ;
32297 int res1 = 0 ;
32298 long val2 ;
32299 int ecode2 = 0 ;
32300 PyObject * obj0 = 0 ;
32301 PyObject * obj1 = 0 ;
32302 char * kwnames[] = {
32303 (char *) "self",(char *) "style", NULL
32304 };
32305
32306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32308 if (!SWIG_IsOK(res1)) {
32309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32310 }
32311 arg1 = reinterpret_cast< wxWindow * >(argp1);
32312 ecode2 = SWIG_AsVal_long(obj1, &val2);
32313 if (!SWIG_IsOK(ecode2)) {
32314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32315 }
32316 arg2 = static_cast< long >(val2);
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 (arg1)->SetWindowStyleFlag(arg2);
32320 wxPyEndAllowThreads(__tstate);
32321 if (PyErr_Occurred()) SWIG_fail;
32322 }
32323 resultobj = SWIG_Py_Void();
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331 PyObject *resultobj = 0;
32332 wxWindow *arg1 = (wxWindow *) 0 ;
32333 long result;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 PyObject *swig_obj[1] ;
32337
32338 if (!args) SWIG_fail;
32339 swig_obj[0] = args;
32340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32341 if (!SWIG_IsOK(res1)) {
32342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32343 }
32344 arg1 = reinterpret_cast< wxWindow * >(argp1);
32345 {
32346 PyThreadState* __tstate = wxPyBeginAllowThreads();
32347 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 resultobj = SWIG_From_long(static_cast< long >(result));
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32359 PyObject *resultobj = 0;
32360 wxWindow *arg1 = (wxWindow *) 0 ;
32361 int arg2 ;
32362 bool result;
32363 void *argp1 = 0 ;
32364 int res1 = 0 ;
32365 int val2 ;
32366 int ecode2 = 0 ;
32367 PyObject * obj0 = 0 ;
32368 PyObject * obj1 = 0 ;
32369 char * kwnames[] = {
32370 (char *) "self",(char *) "flag", NULL
32371 };
32372
32373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32375 if (!SWIG_IsOK(res1)) {
32376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32377 }
32378 arg1 = reinterpret_cast< wxWindow * >(argp1);
32379 ecode2 = SWIG_AsVal_int(obj1, &val2);
32380 if (!SWIG_IsOK(ecode2)) {
32381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32382 }
32383 arg2 = static_cast< int >(val2);
32384 {
32385 PyThreadState* __tstate = wxPyBeginAllowThreads();
32386 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32387 wxPyEndAllowThreads(__tstate);
32388 if (PyErr_Occurred()) SWIG_fail;
32389 }
32390 {
32391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32392 }
32393 return resultobj;
32394 fail:
32395 return NULL;
32396 }
32397
32398
32399 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32400 PyObject *resultobj = 0;
32401 wxWindow *arg1 = (wxWindow *) 0 ;
32402 bool result;
32403 void *argp1 = 0 ;
32404 int res1 = 0 ;
32405 PyObject *swig_obj[1] ;
32406
32407 if (!args) SWIG_fail;
32408 swig_obj[0] = args;
32409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32410 if (!SWIG_IsOK(res1)) {
32411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32412 }
32413 arg1 = reinterpret_cast< wxWindow * >(argp1);
32414 {
32415 PyThreadState* __tstate = wxPyBeginAllowThreads();
32416 result = (bool)((wxWindow const *)arg1)->IsRetained();
32417 wxPyEndAllowThreads(__tstate);
32418 if (PyErr_Occurred()) SWIG_fail;
32419 }
32420 {
32421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32422 }
32423 return resultobj;
32424 fail:
32425 return NULL;
32426 }
32427
32428
32429 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32430 PyObject *resultobj = 0;
32431 wxWindow *arg1 = (wxWindow *) 0 ;
32432 long arg2 ;
32433 void *argp1 = 0 ;
32434 int res1 = 0 ;
32435 long val2 ;
32436 int ecode2 = 0 ;
32437 PyObject * obj0 = 0 ;
32438 PyObject * obj1 = 0 ;
32439 char * kwnames[] = {
32440 (char *) "self",(char *) "exStyle", NULL
32441 };
32442
32443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32445 if (!SWIG_IsOK(res1)) {
32446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32447 }
32448 arg1 = reinterpret_cast< wxWindow * >(argp1);
32449 ecode2 = SWIG_AsVal_long(obj1, &val2);
32450 if (!SWIG_IsOK(ecode2)) {
32451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32452 }
32453 arg2 = static_cast< long >(val2);
32454 {
32455 PyThreadState* __tstate = wxPyBeginAllowThreads();
32456 (arg1)->SetExtraStyle(arg2);
32457 wxPyEndAllowThreads(__tstate);
32458 if (PyErr_Occurred()) SWIG_fail;
32459 }
32460 resultobj = SWIG_Py_Void();
32461 return resultobj;
32462 fail:
32463 return NULL;
32464 }
32465
32466
32467 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32468 PyObject *resultobj = 0;
32469 wxWindow *arg1 = (wxWindow *) 0 ;
32470 long result;
32471 void *argp1 = 0 ;
32472 int res1 = 0 ;
32473 PyObject *swig_obj[1] ;
32474
32475 if (!args) SWIG_fail;
32476 swig_obj[0] = args;
32477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32478 if (!SWIG_IsOK(res1)) {
32479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32480 }
32481 arg1 = reinterpret_cast< wxWindow * >(argp1);
32482 {
32483 PyThreadState* __tstate = wxPyBeginAllowThreads();
32484 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 resultobj = SWIG_From_long(static_cast< long >(result));
32489 return resultobj;
32490 fail:
32491 return NULL;
32492 }
32493
32494
32495 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32496 PyObject *resultobj = 0;
32497 wxWindow *arg1 = (wxWindow *) 0 ;
32498 bool arg2 = (bool) true ;
32499 void *argp1 = 0 ;
32500 int res1 = 0 ;
32501 bool val2 ;
32502 int ecode2 = 0 ;
32503 PyObject * obj0 = 0 ;
32504 PyObject * obj1 = 0 ;
32505 char * kwnames[] = {
32506 (char *) "self",(char *) "modal", NULL
32507 };
32508
32509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32513 }
32514 arg1 = reinterpret_cast< wxWindow * >(argp1);
32515 if (obj1) {
32516 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32517 if (!SWIG_IsOK(ecode2)) {
32518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32519 }
32520 arg2 = static_cast< bool >(val2);
32521 }
32522 {
32523 PyThreadState* __tstate = wxPyBeginAllowThreads();
32524 (arg1)->MakeModal(arg2);
32525 wxPyEndAllowThreads(__tstate);
32526 if (PyErr_Occurred()) SWIG_fail;
32527 }
32528 resultobj = SWIG_Py_Void();
32529 return resultobj;
32530 fail:
32531 return NULL;
32532 }
32533
32534
32535 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32536 PyObject *resultobj = 0;
32537 wxWindow *arg1 = (wxWindow *) 0 ;
32538 bool arg2 ;
32539 void *argp1 = 0 ;
32540 int res1 = 0 ;
32541 bool val2 ;
32542 int ecode2 = 0 ;
32543 PyObject * obj0 = 0 ;
32544 PyObject * obj1 = 0 ;
32545 char * kwnames[] = {
32546 (char *) "self",(char *) "enableTheme", NULL
32547 };
32548
32549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32551 if (!SWIG_IsOK(res1)) {
32552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32553 }
32554 arg1 = reinterpret_cast< wxWindow * >(argp1);
32555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32556 if (!SWIG_IsOK(ecode2)) {
32557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32558 }
32559 arg2 = static_cast< bool >(val2);
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 (arg1)->SetThemeEnabled(arg2);
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 resultobj = SWIG_Py_Void();
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32574 PyObject *resultobj = 0;
32575 wxWindow *arg1 = (wxWindow *) 0 ;
32576 bool result;
32577 void *argp1 = 0 ;
32578 int res1 = 0 ;
32579 PyObject *swig_obj[1] ;
32580
32581 if (!args) SWIG_fail;
32582 swig_obj[0] = args;
32583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32584 if (!SWIG_IsOK(res1)) {
32585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32586 }
32587 arg1 = reinterpret_cast< wxWindow * >(argp1);
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 {
32595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32596 }
32597 return resultobj;
32598 fail:
32599 return NULL;
32600 }
32601
32602
32603 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32604 PyObject *resultobj = 0;
32605 wxWindow *arg1 = (wxWindow *) 0 ;
32606 void *argp1 = 0 ;
32607 int res1 = 0 ;
32608 PyObject *swig_obj[1] ;
32609
32610 if (!args) SWIG_fail;
32611 swig_obj[0] = args;
32612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32613 if (!SWIG_IsOK(res1)) {
32614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32615 }
32616 arg1 = reinterpret_cast< wxWindow * >(argp1);
32617 {
32618 PyThreadState* __tstate = wxPyBeginAllowThreads();
32619 (arg1)->SetFocus();
32620 wxPyEndAllowThreads(__tstate);
32621 if (PyErr_Occurred()) SWIG_fail;
32622 }
32623 resultobj = SWIG_Py_Void();
32624 return resultobj;
32625 fail:
32626 return NULL;
32627 }
32628
32629
32630 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32631 PyObject *resultobj = 0;
32632 wxWindow *arg1 = (wxWindow *) 0 ;
32633 void *argp1 = 0 ;
32634 int res1 = 0 ;
32635 PyObject *swig_obj[1] ;
32636
32637 if (!args) SWIG_fail;
32638 swig_obj[0] = args;
32639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32640 if (!SWIG_IsOK(res1)) {
32641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32642 }
32643 arg1 = reinterpret_cast< wxWindow * >(argp1);
32644 {
32645 PyThreadState* __tstate = wxPyBeginAllowThreads();
32646 (arg1)->SetFocusFromKbd();
32647 wxPyEndAllowThreads(__tstate);
32648 if (PyErr_Occurred()) SWIG_fail;
32649 }
32650 resultobj = SWIG_Py_Void();
32651 return resultobj;
32652 fail:
32653 return NULL;
32654 }
32655
32656
32657 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32658 PyObject *resultobj = 0;
32659 wxWindow *result = 0 ;
32660
32661 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32662 {
32663 if (!wxPyCheckForApp()) SWIG_fail;
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 result = (wxWindow *)wxWindow::FindFocus();
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 {
32670 resultobj = wxPyMake_wxObject(result, 0);
32671 }
32672 return resultobj;
32673 fail:
32674 return NULL;
32675 }
32676
32677
32678 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32679 PyObject *resultobj = 0;
32680 wxWindow *arg1 = (wxWindow *) 0 ;
32681 bool result;
32682 void *argp1 = 0 ;
32683 int res1 = 0 ;
32684 PyObject *swig_obj[1] ;
32685
32686 if (!args) SWIG_fail;
32687 swig_obj[0] = args;
32688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32689 if (!SWIG_IsOK(res1)) {
32690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32691 }
32692 arg1 = reinterpret_cast< wxWindow * >(argp1);
32693 {
32694 PyThreadState* __tstate = wxPyBeginAllowThreads();
32695 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32696 wxPyEndAllowThreads(__tstate);
32697 if (PyErr_Occurred()) SWIG_fail;
32698 }
32699 {
32700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32701 }
32702 return resultobj;
32703 fail:
32704 return NULL;
32705 }
32706
32707
32708 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32709 PyObject *resultobj = 0;
32710 wxWindow *arg1 = (wxWindow *) 0 ;
32711 bool result;
32712 void *argp1 = 0 ;
32713 int res1 = 0 ;
32714 PyObject *swig_obj[1] ;
32715
32716 if (!args) SWIG_fail;
32717 swig_obj[0] = args;
32718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32719 if (!SWIG_IsOK(res1)) {
32720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32721 }
32722 arg1 = reinterpret_cast< wxWindow * >(argp1);
32723 {
32724 PyThreadState* __tstate = wxPyBeginAllowThreads();
32725 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32726 wxPyEndAllowThreads(__tstate);
32727 if (PyErr_Occurred()) SWIG_fail;
32728 }
32729 {
32730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32731 }
32732 return resultobj;
32733 fail:
32734 return NULL;
32735 }
32736
32737
32738 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32739 PyObject *resultobj = 0;
32740 wxWindow *arg1 = (wxWindow *) 0 ;
32741 wxWindow *result = 0 ;
32742 void *argp1 = 0 ;
32743 int res1 = 0 ;
32744 PyObject *swig_obj[1] ;
32745
32746 if (!args) SWIG_fail;
32747 swig_obj[0] = args;
32748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32749 if (!SWIG_IsOK(res1)) {
32750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32751 }
32752 arg1 = reinterpret_cast< wxWindow * >(argp1);
32753 {
32754 PyThreadState* __tstate = wxPyBeginAllowThreads();
32755 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32756 wxPyEndAllowThreads(__tstate);
32757 if (PyErr_Occurred()) SWIG_fail;
32758 }
32759 {
32760 resultobj = wxPyMake_wxObject(result, 0);
32761 }
32762 return resultobj;
32763 fail:
32764 return NULL;
32765 }
32766
32767
32768 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32769 PyObject *resultobj = 0;
32770 wxWindow *arg1 = (wxWindow *) 0 ;
32771 wxWindow *arg2 = (wxWindow *) 0 ;
32772 wxWindow *result = 0 ;
32773 void *argp1 = 0 ;
32774 int res1 = 0 ;
32775 void *argp2 = 0 ;
32776 int res2 = 0 ;
32777 PyObject * obj0 = 0 ;
32778 PyObject * obj1 = 0 ;
32779 char * kwnames[] = {
32780 (char *) "self",(char *) "child", NULL
32781 };
32782
32783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32785 if (!SWIG_IsOK(res1)) {
32786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32787 }
32788 arg1 = reinterpret_cast< wxWindow * >(argp1);
32789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32790 if (!SWIG_IsOK(res2)) {
32791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32792 }
32793 arg2 = reinterpret_cast< wxWindow * >(argp2);
32794 {
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 {
32801 resultobj = wxPyMake_wxObject(result, 0);
32802 }
32803 return resultobj;
32804 fail:
32805 return NULL;
32806 }
32807
32808
32809 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32810 PyObject *resultobj = 0;
32811 wxWindow *arg1 = (wxWindow *) 0 ;
32812 wxWindow *arg2 = (wxWindow *) 0 ;
32813 void *argp1 = 0 ;
32814 int res1 = 0 ;
32815 void *argp2 = 0 ;
32816 int res2 = 0 ;
32817 PyObject * obj0 = 0 ;
32818 PyObject * obj1 = 0 ;
32819 char * kwnames[] = {
32820 (char *) "self",(char *) "win", NULL
32821 };
32822
32823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32825 if (!SWIG_IsOK(res1)) {
32826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32827 }
32828 arg1 = reinterpret_cast< wxWindow * >(argp1);
32829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32830 if (!SWIG_IsOK(res2)) {
32831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32832 }
32833 arg2 = reinterpret_cast< wxWindow * >(argp2);
32834 {
32835 PyThreadState* __tstate = wxPyBeginAllowThreads();
32836 (arg1)->SetTmpDefaultItem(arg2);
32837 wxPyEndAllowThreads(__tstate);
32838 if (PyErr_Occurred()) SWIG_fail;
32839 }
32840 resultobj = SWIG_Py_Void();
32841 return resultobj;
32842 fail:
32843 return NULL;
32844 }
32845
32846
32847 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32848 PyObject *resultobj = 0;
32849 wxWindow *arg1 = (wxWindow *) 0 ;
32850 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32851 bool result;
32852 void *argp1 = 0 ;
32853 int res1 = 0 ;
32854 int val2 ;
32855 int ecode2 = 0 ;
32856 PyObject * obj0 = 0 ;
32857 PyObject * obj1 = 0 ;
32858 char * kwnames[] = {
32859 (char *) "self",(char *) "flags", NULL
32860 };
32861
32862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32864 if (!SWIG_IsOK(res1)) {
32865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32866 }
32867 arg1 = reinterpret_cast< wxWindow * >(argp1);
32868 if (obj1) {
32869 ecode2 = SWIG_AsVal_int(obj1, &val2);
32870 if (!SWIG_IsOK(ecode2)) {
32871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32872 }
32873 arg2 = static_cast< int >(val2);
32874 }
32875 {
32876 PyThreadState* __tstate = wxPyBeginAllowThreads();
32877 result = (bool)(arg1)->Navigate(arg2);
32878 wxPyEndAllowThreads(__tstate);
32879 if (PyErr_Occurred()) SWIG_fail;
32880 }
32881 {
32882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32883 }
32884 return resultobj;
32885 fail:
32886 return NULL;
32887 }
32888
32889
32890 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32891 PyObject *resultobj = 0;
32892 wxWindow *arg1 = (wxWindow *) 0 ;
32893 wxWindow *arg2 = (wxWindow *) 0 ;
32894 void *argp1 = 0 ;
32895 int res1 = 0 ;
32896 void *argp2 = 0 ;
32897 int res2 = 0 ;
32898 PyObject * obj0 = 0 ;
32899 PyObject * obj1 = 0 ;
32900 char * kwnames[] = {
32901 (char *) "self",(char *) "win", NULL
32902 };
32903
32904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32906 if (!SWIG_IsOK(res1)) {
32907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32908 }
32909 arg1 = reinterpret_cast< wxWindow * >(argp1);
32910 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32911 if (!SWIG_IsOK(res2)) {
32912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32913 }
32914 arg2 = reinterpret_cast< wxWindow * >(argp2);
32915 {
32916 PyThreadState* __tstate = wxPyBeginAllowThreads();
32917 (arg1)->MoveAfterInTabOrder(arg2);
32918 wxPyEndAllowThreads(__tstate);
32919 if (PyErr_Occurred()) SWIG_fail;
32920 }
32921 resultobj = SWIG_Py_Void();
32922 return resultobj;
32923 fail:
32924 return NULL;
32925 }
32926
32927
32928 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32929 PyObject *resultobj = 0;
32930 wxWindow *arg1 = (wxWindow *) 0 ;
32931 wxWindow *arg2 = (wxWindow *) 0 ;
32932 void *argp1 = 0 ;
32933 int res1 = 0 ;
32934 void *argp2 = 0 ;
32935 int res2 = 0 ;
32936 PyObject * obj0 = 0 ;
32937 PyObject * obj1 = 0 ;
32938 char * kwnames[] = {
32939 (char *) "self",(char *) "win", NULL
32940 };
32941
32942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32944 if (!SWIG_IsOK(res1)) {
32945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32946 }
32947 arg1 = reinterpret_cast< wxWindow * >(argp1);
32948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32949 if (!SWIG_IsOK(res2)) {
32950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32951 }
32952 arg2 = reinterpret_cast< wxWindow * >(argp2);
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 (arg1)->MoveBeforeInTabOrder(arg2);
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 resultobj = SWIG_Py_Void();
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxWindow *arg1 = (wxWindow *) 0 ;
32969 PyObject *result = 0 ;
32970 void *argp1 = 0 ;
32971 int res1 = 0 ;
32972 PyObject *swig_obj[1] ;
32973
32974 if (!args) SWIG_fail;
32975 swig_obj[0] = args;
32976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32977 if (!SWIG_IsOK(res1)) {
32978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32979 }
32980 arg1 = reinterpret_cast< wxWindow * >(argp1);
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (PyObject *)wxWindow_GetChildren(arg1);
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 resultobj = result;
32988 return resultobj;
32989 fail:
32990 return NULL;
32991 }
32992
32993
32994 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32995 PyObject *resultobj = 0;
32996 wxWindow *arg1 = (wxWindow *) 0 ;
32997 wxWindow *result = 0 ;
32998 void *argp1 = 0 ;
32999 int res1 = 0 ;
33000 PyObject *swig_obj[1] ;
33001
33002 if (!args) SWIG_fail;
33003 swig_obj[0] = args;
33004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33005 if (!SWIG_IsOK(res1)) {
33006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33007 }
33008 arg1 = reinterpret_cast< wxWindow * >(argp1);
33009 {
33010 PyThreadState* __tstate = wxPyBeginAllowThreads();
33011 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33012 wxPyEndAllowThreads(__tstate);
33013 if (PyErr_Occurred()) SWIG_fail;
33014 }
33015 {
33016 resultobj = wxPyMake_wxObject(result, 0);
33017 }
33018 return resultobj;
33019 fail:
33020 return NULL;
33021 }
33022
33023
33024 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33025 PyObject *resultobj = 0;
33026 wxWindow *arg1 = (wxWindow *) 0 ;
33027 wxWindow *result = 0 ;
33028 void *argp1 = 0 ;
33029 int res1 = 0 ;
33030 PyObject *swig_obj[1] ;
33031
33032 if (!args) SWIG_fail;
33033 swig_obj[0] = args;
33034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33035 if (!SWIG_IsOK(res1)) {
33036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33037 }
33038 arg1 = reinterpret_cast< wxWindow * >(argp1);
33039 {
33040 PyThreadState* __tstate = wxPyBeginAllowThreads();
33041 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33042 wxPyEndAllowThreads(__tstate);
33043 if (PyErr_Occurred()) SWIG_fail;
33044 }
33045 {
33046 resultobj = wxPyMake_wxObject(result, 0);
33047 }
33048 return resultobj;
33049 fail:
33050 return NULL;
33051 }
33052
33053
33054 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33055 PyObject *resultobj = 0;
33056 wxWindow *arg1 = (wxWindow *) 0 ;
33057 bool result;
33058 void *argp1 = 0 ;
33059 int res1 = 0 ;
33060 PyObject *swig_obj[1] ;
33061
33062 if (!args) SWIG_fail;
33063 swig_obj[0] = args;
33064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33065 if (!SWIG_IsOK(res1)) {
33066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33067 }
33068 arg1 = reinterpret_cast< wxWindow * >(argp1);
33069 {
33070 PyThreadState* __tstate = wxPyBeginAllowThreads();
33071 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33072 wxPyEndAllowThreads(__tstate);
33073 if (PyErr_Occurred()) SWIG_fail;
33074 }
33075 {
33076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33077 }
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33085 PyObject *resultobj = 0;
33086 wxWindow *arg1 = (wxWindow *) 0 ;
33087 wxWindow *arg2 = (wxWindow *) 0 ;
33088 bool result;
33089 void *argp1 = 0 ;
33090 int res1 = 0 ;
33091 void *argp2 = 0 ;
33092 int res2 = 0 ;
33093 PyObject * obj0 = 0 ;
33094 PyObject * obj1 = 0 ;
33095 char * kwnames[] = {
33096 (char *) "self",(char *) "newParent", NULL
33097 };
33098
33099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33101 if (!SWIG_IsOK(res1)) {
33102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33103 }
33104 arg1 = reinterpret_cast< wxWindow * >(argp1);
33105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33106 if (!SWIG_IsOK(res2)) {
33107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33108 }
33109 arg2 = reinterpret_cast< wxWindow * >(argp2);
33110 {
33111 PyThreadState* __tstate = wxPyBeginAllowThreads();
33112 result = (bool)(arg1)->Reparent(arg2);
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 {
33117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33118 }
33119 return resultobj;
33120 fail:
33121 return NULL;
33122 }
33123
33124
33125 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33126 PyObject *resultobj = 0;
33127 wxWindow *arg1 = (wxWindow *) 0 ;
33128 wxWindow *arg2 = (wxWindow *) 0 ;
33129 void *argp1 = 0 ;
33130 int res1 = 0 ;
33131 void *argp2 = 0 ;
33132 int res2 = 0 ;
33133 PyObject * obj0 = 0 ;
33134 PyObject * obj1 = 0 ;
33135 char * kwnames[] = {
33136 (char *) "self",(char *) "child", NULL
33137 };
33138
33139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33141 if (!SWIG_IsOK(res1)) {
33142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33143 }
33144 arg1 = reinterpret_cast< wxWindow * >(argp1);
33145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33146 if (!SWIG_IsOK(res2)) {
33147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33148 }
33149 arg2 = reinterpret_cast< wxWindow * >(argp2);
33150 {
33151 PyThreadState* __tstate = wxPyBeginAllowThreads();
33152 (arg1)->AddChild(arg2);
33153 wxPyEndAllowThreads(__tstate);
33154 if (PyErr_Occurred()) SWIG_fail;
33155 }
33156 resultobj = SWIG_Py_Void();
33157 return resultobj;
33158 fail:
33159 return NULL;
33160 }
33161
33162
33163 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33164 PyObject *resultobj = 0;
33165 wxWindow *arg1 = (wxWindow *) 0 ;
33166 wxWindow *arg2 = (wxWindow *) 0 ;
33167 void *argp1 = 0 ;
33168 int res1 = 0 ;
33169 void *argp2 = 0 ;
33170 int res2 = 0 ;
33171 PyObject * obj0 = 0 ;
33172 PyObject * obj1 = 0 ;
33173 char * kwnames[] = {
33174 (char *) "self",(char *) "child", NULL
33175 };
33176
33177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33179 if (!SWIG_IsOK(res1)) {
33180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33181 }
33182 arg1 = reinterpret_cast< wxWindow * >(argp1);
33183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33184 if (!SWIG_IsOK(res2)) {
33185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33186 }
33187 arg2 = reinterpret_cast< wxWindow * >(argp2);
33188 {
33189 PyThreadState* __tstate = wxPyBeginAllowThreads();
33190 (arg1)->RemoveChild(arg2);
33191 wxPyEndAllowThreads(__tstate);
33192 if (PyErr_Occurred()) SWIG_fail;
33193 }
33194 resultobj = SWIG_Py_Void();
33195 return resultobj;
33196 fail:
33197 return NULL;
33198 }
33199
33200
33201 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33202 PyObject *resultobj = 0;
33203 wxWindow *arg1 = (wxWindow *) 0 ;
33204 bool arg2 ;
33205 void *argp1 = 0 ;
33206 int res1 = 0 ;
33207 bool val2 ;
33208 int ecode2 = 0 ;
33209 PyObject * obj0 = 0 ;
33210 PyObject * obj1 = 0 ;
33211 char * kwnames[] = {
33212 (char *) "self",(char *) "on", NULL
33213 };
33214
33215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33217 if (!SWIG_IsOK(res1)) {
33218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33219 }
33220 arg1 = reinterpret_cast< wxWindow * >(argp1);
33221 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33222 if (!SWIG_IsOK(ecode2)) {
33223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33224 }
33225 arg2 = static_cast< bool >(val2);
33226 {
33227 PyThreadState* __tstate = wxPyBeginAllowThreads();
33228 (arg1)->SetDoubleBuffered(arg2);
33229 wxPyEndAllowThreads(__tstate);
33230 if (PyErr_Occurred()) SWIG_fail;
33231 }
33232 resultobj = SWIG_Py_Void();
33233 return resultobj;
33234 fail:
33235 return NULL;
33236 }
33237
33238
33239 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33240 PyObject *resultobj = 0;
33241 wxWindow *arg1 = (wxWindow *) 0 ;
33242 long arg2 ;
33243 wxWindow *result = 0 ;
33244 void *argp1 = 0 ;
33245 int res1 = 0 ;
33246 long val2 ;
33247 int ecode2 = 0 ;
33248 PyObject * obj0 = 0 ;
33249 PyObject * obj1 = 0 ;
33250 char * kwnames[] = {
33251 (char *) "self",(char *) "winid", NULL
33252 };
33253
33254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33256 if (!SWIG_IsOK(res1)) {
33257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33258 }
33259 arg1 = reinterpret_cast< wxWindow * >(argp1);
33260 ecode2 = SWIG_AsVal_long(obj1, &val2);
33261 if (!SWIG_IsOK(ecode2)) {
33262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33263 }
33264 arg2 = static_cast< long >(val2);
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 result = (wxWindow *)(arg1)->FindWindow(arg2);
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 {
33272 resultobj = wxPyMake_wxObject(result, 0);
33273 }
33274 return resultobj;
33275 fail:
33276 return NULL;
33277 }
33278
33279
33280 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33281 PyObject *resultobj = 0;
33282 wxWindow *arg1 = (wxWindow *) 0 ;
33283 wxString *arg2 = 0 ;
33284 wxWindow *result = 0 ;
33285 void *argp1 = 0 ;
33286 int res1 = 0 ;
33287 bool temp2 = false ;
33288 PyObject * obj0 = 0 ;
33289 PyObject * obj1 = 0 ;
33290 char * kwnames[] = {
33291 (char *) "self",(char *) "name", NULL
33292 };
33293
33294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33296 if (!SWIG_IsOK(res1)) {
33297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33298 }
33299 arg1 = reinterpret_cast< wxWindow * >(argp1);
33300 {
33301 arg2 = wxString_in_helper(obj1);
33302 if (arg2 == NULL) SWIG_fail;
33303 temp2 = true;
33304 }
33305 {
33306 PyThreadState* __tstate = wxPyBeginAllowThreads();
33307 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 {
33312 resultobj = wxPyMake_wxObject(result, 0);
33313 }
33314 {
33315 if (temp2)
33316 delete arg2;
33317 }
33318 return resultobj;
33319 fail:
33320 {
33321 if (temp2)
33322 delete arg2;
33323 }
33324 return NULL;
33325 }
33326
33327
33328 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33329 PyObject *resultobj = 0;
33330 wxWindow *arg1 = (wxWindow *) 0 ;
33331 wxEvtHandler *result = 0 ;
33332 void *argp1 = 0 ;
33333 int res1 = 0 ;
33334 PyObject *swig_obj[1] ;
33335
33336 if (!args) SWIG_fail;
33337 swig_obj[0] = args;
33338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33339 if (!SWIG_IsOK(res1)) {
33340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33341 }
33342 arg1 = reinterpret_cast< wxWindow * >(argp1);
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 {
33350 resultobj = wxPyMake_wxObject(result, 0);
33351 }
33352 return resultobj;
33353 fail:
33354 return NULL;
33355 }
33356
33357
33358 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33359 PyObject *resultobj = 0;
33360 wxWindow *arg1 = (wxWindow *) 0 ;
33361 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33362 void *argp1 = 0 ;
33363 int res1 = 0 ;
33364 void *argp2 = 0 ;
33365 int res2 = 0 ;
33366 PyObject * obj0 = 0 ;
33367 PyObject * obj1 = 0 ;
33368 char * kwnames[] = {
33369 (char *) "self",(char *) "handler", NULL
33370 };
33371
33372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33374 if (!SWIG_IsOK(res1)) {
33375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33376 }
33377 arg1 = reinterpret_cast< wxWindow * >(argp1);
33378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33379 if (!SWIG_IsOK(res2)) {
33380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33381 }
33382 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33383 {
33384 PyThreadState* __tstate = wxPyBeginAllowThreads();
33385 (arg1)->SetEventHandler(arg2);
33386 wxPyEndAllowThreads(__tstate);
33387 if (PyErr_Occurred()) SWIG_fail;
33388 }
33389 resultobj = SWIG_Py_Void();
33390 return resultobj;
33391 fail:
33392 return NULL;
33393 }
33394
33395
33396 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33397 PyObject *resultobj = 0;
33398 wxWindow *arg1 = (wxWindow *) 0 ;
33399 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33400 void *argp1 = 0 ;
33401 int res1 = 0 ;
33402 void *argp2 = 0 ;
33403 int res2 = 0 ;
33404 PyObject * obj0 = 0 ;
33405 PyObject * obj1 = 0 ;
33406 char * kwnames[] = {
33407 (char *) "self",(char *) "handler", NULL
33408 };
33409
33410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33412 if (!SWIG_IsOK(res1)) {
33413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33414 }
33415 arg1 = reinterpret_cast< wxWindow * >(argp1);
33416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33417 if (!SWIG_IsOK(res2)) {
33418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33419 }
33420 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33421 {
33422 PyThreadState* __tstate = wxPyBeginAllowThreads();
33423 (arg1)->PushEventHandler(arg2);
33424 wxPyEndAllowThreads(__tstate);
33425 if (PyErr_Occurred()) SWIG_fail;
33426 }
33427 resultobj = SWIG_Py_Void();
33428 return resultobj;
33429 fail:
33430 return NULL;
33431 }
33432
33433
33434 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33435 PyObject *resultobj = 0;
33436 wxWindow *arg1 = (wxWindow *) 0 ;
33437 bool arg2 = (bool) false ;
33438 wxEvtHandler *result = 0 ;
33439 void *argp1 = 0 ;
33440 int res1 = 0 ;
33441 bool val2 ;
33442 int ecode2 = 0 ;
33443 PyObject * obj0 = 0 ;
33444 PyObject * obj1 = 0 ;
33445 char * kwnames[] = {
33446 (char *) "self",(char *) "deleteHandler", NULL
33447 };
33448
33449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33451 if (!SWIG_IsOK(res1)) {
33452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33453 }
33454 arg1 = reinterpret_cast< wxWindow * >(argp1);
33455 if (obj1) {
33456 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33457 if (!SWIG_IsOK(ecode2)) {
33458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33459 }
33460 arg2 = static_cast< bool >(val2);
33461 }
33462 {
33463 PyThreadState* __tstate = wxPyBeginAllowThreads();
33464 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33465 wxPyEndAllowThreads(__tstate);
33466 if (PyErr_Occurred()) SWIG_fail;
33467 }
33468 {
33469 resultobj = wxPyMake_wxObject(result, 0);
33470 }
33471 return resultobj;
33472 fail:
33473 return NULL;
33474 }
33475
33476
33477 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33478 PyObject *resultobj = 0;
33479 wxWindow *arg1 = (wxWindow *) 0 ;
33480 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33481 bool result;
33482 void *argp1 = 0 ;
33483 int res1 = 0 ;
33484 void *argp2 = 0 ;
33485 int res2 = 0 ;
33486 PyObject * obj0 = 0 ;
33487 PyObject * obj1 = 0 ;
33488 char * kwnames[] = {
33489 (char *) "self",(char *) "handler", NULL
33490 };
33491
33492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33494 if (!SWIG_IsOK(res1)) {
33495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33496 }
33497 arg1 = reinterpret_cast< wxWindow * >(argp1);
33498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33499 if (!SWIG_IsOK(res2)) {
33500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33501 }
33502 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33503 {
33504 PyThreadState* __tstate = wxPyBeginAllowThreads();
33505 result = (bool)(arg1)->RemoveEventHandler(arg2);
33506 wxPyEndAllowThreads(__tstate);
33507 if (PyErr_Occurred()) SWIG_fail;
33508 }
33509 {
33510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33511 }
33512 return resultobj;
33513 fail:
33514 return NULL;
33515 }
33516
33517
33518 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33519 PyObject *resultobj = 0;
33520 wxWindow *arg1 = (wxWindow *) 0 ;
33521 wxValidator *arg2 = 0 ;
33522 void *argp1 = 0 ;
33523 int res1 = 0 ;
33524 void *argp2 = 0 ;
33525 int res2 = 0 ;
33526 PyObject * obj0 = 0 ;
33527 PyObject * obj1 = 0 ;
33528 char * kwnames[] = {
33529 (char *) "self",(char *) "validator", NULL
33530 };
33531
33532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33534 if (!SWIG_IsOK(res1)) {
33535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33536 }
33537 arg1 = reinterpret_cast< wxWindow * >(argp1);
33538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33539 if (!SWIG_IsOK(res2)) {
33540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33541 }
33542 if (!argp2) {
33543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33544 }
33545 arg2 = reinterpret_cast< wxValidator * >(argp2);
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 (arg1)->SetValidator((wxValidator const &)*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_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33560 PyObject *resultobj = 0;
33561 wxWindow *arg1 = (wxWindow *) 0 ;
33562 wxValidator *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_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33572 }
33573 arg1 = reinterpret_cast< wxWindow * >(argp1);
33574 {
33575 PyThreadState* __tstate = wxPyBeginAllowThreads();
33576 result = (wxValidator *)(arg1)->GetValidator();
33577 wxPyEndAllowThreads(__tstate);
33578 if (PyErr_Occurred()) SWIG_fail;
33579 }
33580 {
33581 resultobj = wxPyMake_wxObject(result, (bool)0);
33582 }
33583 return resultobj;
33584 fail:
33585 return NULL;
33586 }
33587
33588
33589 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33590 PyObject *resultobj = 0;
33591 wxWindow *arg1 = (wxWindow *) 0 ;
33592 bool result;
33593 void *argp1 = 0 ;
33594 int res1 = 0 ;
33595 PyObject *swig_obj[1] ;
33596
33597 if (!args) SWIG_fail;
33598 swig_obj[0] = args;
33599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33600 if (!SWIG_IsOK(res1)) {
33601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33602 }
33603 arg1 = reinterpret_cast< wxWindow * >(argp1);
33604 {
33605 PyThreadState* __tstate = wxPyBeginAllowThreads();
33606 result = (bool)(arg1)->Validate();
33607 wxPyEndAllowThreads(__tstate);
33608 if (PyErr_Occurred()) SWIG_fail;
33609 }
33610 {
33611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33612 }
33613 return resultobj;
33614 fail:
33615 return NULL;
33616 }
33617
33618
33619 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33620 PyObject *resultobj = 0;
33621 wxWindow *arg1 = (wxWindow *) 0 ;
33622 bool result;
33623 void *argp1 = 0 ;
33624 int res1 = 0 ;
33625 PyObject *swig_obj[1] ;
33626
33627 if (!args) SWIG_fail;
33628 swig_obj[0] = args;
33629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33630 if (!SWIG_IsOK(res1)) {
33631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33632 }
33633 arg1 = reinterpret_cast< wxWindow * >(argp1);
33634 {
33635 PyThreadState* __tstate = wxPyBeginAllowThreads();
33636 result = (bool)(arg1)->TransferDataToWindow();
33637 wxPyEndAllowThreads(__tstate);
33638 if (PyErr_Occurred()) SWIG_fail;
33639 }
33640 {
33641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33642 }
33643 return resultobj;
33644 fail:
33645 return NULL;
33646 }
33647
33648
33649 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33650 PyObject *resultobj = 0;
33651 wxWindow *arg1 = (wxWindow *) 0 ;
33652 bool result;
33653 void *argp1 = 0 ;
33654 int res1 = 0 ;
33655 PyObject *swig_obj[1] ;
33656
33657 if (!args) SWIG_fail;
33658 swig_obj[0] = args;
33659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33660 if (!SWIG_IsOK(res1)) {
33661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33662 }
33663 arg1 = reinterpret_cast< wxWindow * >(argp1);
33664 {
33665 PyThreadState* __tstate = wxPyBeginAllowThreads();
33666 result = (bool)(arg1)->TransferDataFromWindow();
33667 wxPyEndAllowThreads(__tstate);
33668 if (PyErr_Occurred()) SWIG_fail;
33669 }
33670 {
33671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33672 }
33673 return resultobj;
33674 fail:
33675 return NULL;
33676 }
33677
33678
33679 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33680 PyObject *resultobj = 0;
33681 wxWindow *arg1 = (wxWindow *) 0 ;
33682 void *argp1 = 0 ;
33683 int res1 = 0 ;
33684 PyObject *swig_obj[1] ;
33685
33686 if (!args) SWIG_fail;
33687 swig_obj[0] = args;
33688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33689 if (!SWIG_IsOK(res1)) {
33690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33691 }
33692 arg1 = reinterpret_cast< wxWindow * >(argp1);
33693 {
33694 PyThreadState* __tstate = wxPyBeginAllowThreads();
33695 (arg1)->InitDialog();
33696 wxPyEndAllowThreads(__tstate);
33697 if (PyErr_Occurred()) SWIG_fail;
33698 }
33699 resultobj = SWIG_Py_Void();
33700 return resultobj;
33701 fail:
33702 return NULL;
33703 }
33704
33705
33706 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33707 PyObject *resultobj = 0;
33708 wxWindow *arg1 = (wxWindow *) 0 ;
33709 wxAcceleratorTable *arg2 = 0 ;
33710 void *argp1 = 0 ;
33711 int res1 = 0 ;
33712 void *argp2 = 0 ;
33713 int res2 = 0 ;
33714 PyObject * obj0 = 0 ;
33715 PyObject * obj1 = 0 ;
33716 char * kwnames[] = {
33717 (char *) "self",(char *) "accel", NULL
33718 };
33719
33720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33722 if (!SWIG_IsOK(res1)) {
33723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33724 }
33725 arg1 = reinterpret_cast< wxWindow * >(argp1);
33726 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33727 if (!SWIG_IsOK(res2)) {
33728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33729 }
33730 if (!argp2) {
33731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33732 }
33733 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33734 {
33735 PyThreadState* __tstate = wxPyBeginAllowThreads();
33736 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33737 wxPyEndAllowThreads(__tstate);
33738 if (PyErr_Occurred()) SWIG_fail;
33739 }
33740 resultobj = SWIG_Py_Void();
33741 return resultobj;
33742 fail:
33743 return NULL;
33744 }
33745
33746
33747 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33748 PyObject *resultobj = 0;
33749 wxWindow *arg1 = (wxWindow *) 0 ;
33750 wxAcceleratorTable *result = 0 ;
33751 void *argp1 = 0 ;
33752 int res1 = 0 ;
33753 PyObject *swig_obj[1] ;
33754
33755 if (!args) SWIG_fail;
33756 swig_obj[0] = args;
33757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33758 if (!SWIG_IsOK(res1)) {
33759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33760 }
33761 arg1 = reinterpret_cast< wxWindow * >(argp1);
33762 {
33763 PyThreadState* __tstate = wxPyBeginAllowThreads();
33764 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33765 wxPyEndAllowThreads(__tstate);
33766 if (PyErr_Occurred()) SWIG_fail;
33767 }
33768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33769 return resultobj;
33770 fail:
33771 return NULL;
33772 }
33773
33774
33775 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33776 PyObject *resultobj = 0;
33777 wxWindow *arg1 = (wxWindow *) 0 ;
33778 int arg2 ;
33779 int arg3 ;
33780 int arg4 ;
33781 bool result;
33782 void *argp1 = 0 ;
33783 int res1 = 0 ;
33784 int val2 ;
33785 int ecode2 = 0 ;
33786 int val3 ;
33787 int ecode3 = 0 ;
33788 int val4 ;
33789 int ecode4 = 0 ;
33790 PyObject * obj0 = 0 ;
33791 PyObject * obj1 = 0 ;
33792 PyObject * obj2 = 0 ;
33793 PyObject * obj3 = 0 ;
33794 char * kwnames[] = {
33795 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33796 };
33797
33798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33800 if (!SWIG_IsOK(res1)) {
33801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33802 }
33803 arg1 = reinterpret_cast< wxWindow * >(argp1);
33804 ecode2 = SWIG_AsVal_int(obj1, &val2);
33805 if (!SWIG_IsOK(ecode2)) {
33806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33807 }
33808 arg2 = static_cast< int >(val2);
33809 ecode3 = SWIG_AsVal_int(obj2, &val3);
33810 if (!SWIG_IsOK(ecode3)) {
33811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33812 }
33813 arg3 = static_cast< int >(val3);
33814 ecode4 = SWIG_AsVal_int(obj3, &val4);
33815 if (!SWIG_IsOK(ecode4)) {
33816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33817 }
33818 arg4 = static_cast< int >(val4);
33819 {
33820 PyThreadState* __tstate = wxPyBeginAllowThreads();
33821 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33822 wxPyEndAllowThreads(__tstate);
33823 if (PyErr_Occurred()) SWIG_fail;
33824 }
33825 {
33826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33827 }
33828 return resultobj;
33829 fail:
33830 return NULL;
33831 }
33832
33833
33834 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33835 PyObject *resultobj = 0;
33836 wxWindow *arg1 = (wxWindow *) 0 ;
33837 int arg2 ;
33838 bool result;
33839 void *argp1 = 0 ;
33840 int res1 = 0 ;
33841 int val2 ;
33842 int ecode2 = 0 ;
33843 PyObject * obj0 = 0 ;
33844 PyObject * obj1 = 0 ;
33845 char * kwnames[] = {
33846 (char *) "self",(char *) "hotkeyId", NULL
33847 };
33848
33849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33851 if (!SWIG_IsOK(res1)) {
33852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33853 }
33854 arg1 = reinterpret_cast< wxWindow * >(argp1);
33855 ecode2 = SWIG_AsVal_int(obj1, &val2);
33856 if (!SWIG_IsOK(ecode2)) {
33857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33858 }
33859 arg2 = static_cast< int >(val2);
33860 {
33861 PyThreadState* __tstate = wxPyBeginAllowThreads();
33862 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33863 wxPyEndAllowThreads(__tstate);
33864 if (PyErr_Occurred()) SWIG_fail;
33865 }
33866 {
33867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33868 }
33869 return resultobj;
33870 fail:
33871 return NULL;
33872 }
33873
33874
33875 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33876 PyObject *resultobj = 0;
33877 wxWindow *arg1 = (wxWindow *) 0 ;
33878 wxPoint *arg2 = 0 ;
33879 wxPoint result;
33880 void *argp1 = 0 ;
33881 int res1 = 0 ;
33882 wxPoint temp2 ;
33883 PyObject * obj0 = 0 ;
33884 PyObject * obj1 = 0 ;
33885 char * kwnames[] = {
33886 (char *) "self",(char *) "pt", NULL
33887 };
33888
33889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33891 if (!SWIG_IsOK(res1)) {
33892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33893 }
33894 arg1 = reinterpret_cast< wxWindow * >(argp1);
33895 {
33896 arg2 = &temp2;
33897 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33898 }
33899 {
33900 PyThreadState* __tstate = wxPyBeginAllowThreads();
33901 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33906 return resultobj;
33907 fail:
33908 return NULL;
33909 }
33910
33911
33912 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33913 PyObject *resultobj = 0;
33914 wxWindow *arg1 = (wxWindow *) 0 ;
33915 wxSize *arg2 = 0 ;
33916 wxSize result;
33917 void *argp1 = 0 ;
33918 int res1 = 0 ;
33919 wxSize temp2 ;
33920 PyObject * obj0 = 0 ;
33921 PyObject * obj1 = 0 ;
33922 char * kwnames[] = {
33923 (char *) "self",(char *) "sz", NULL
33924 };
33925
33926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33928 if (!SWIG_IsOK(res1)) {
33929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33930 }
33931 arg1 = reinterpret_cast< wxWindow * >(argp1);
33932 {
33933 arg2 = &temp2;
33934 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33935 }
33936 {
33937 PyThreadState* __tstate = wxPyBeginAllowThreads();
33938 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33939 wxPyEndAllowThreads(__tstate);
33940 if (PyErr_Occurred()) SWIG_fail;
33941 }
33942 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33943 return resultobj;
33944 fail:
33945 return NULL;
33946 }
33947
33948
33949 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33950 PyObject *resultobj = 0;
33951 wxWindow *arg1 = (wxWindow *) 0 ;
33952 wxPoint *arg2 = 0 ;
33953 wxPoint result;
33954 void *argp1 = 0 ;
33955 int res1 = 0 ;
33956 wxPoint temp2 ;
33957 PyObject * obj0 = 0 ;
33958 PyObject * obj1 = 0 ;
33959 char * kwnames[] = {
33960 (char *) "self",(char *) "pt", NULL
33961 };
33962
33963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33965 if (!SWIG_IsOK(res1)) {
33966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33967 }
33968 arg1 = reinterpret_cast< wxWindow * >(argp1);
33969 {
33970 arg2 = &temp2;
33971 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33972 }
33973 {
33974 PyThreadState* __tstate = wxPyBeginAllowThreads();
33975 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33980 return resultobj;
33981 fail:
33982 return NULL;
33983 }
33984
33985
33986 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33987 PyObject *resultobj = 0;
33988 wxWindow *arg1 = (wxWindow *) 0 ;
33989 wxSize *arg2 = 0 ;
33990 wxSize result;
33991 void *argp1 = 0 ;
33992 int res1 = 0 ;
33993 wxSize temp2 ;
33994 PyObject * obj0 = 0 ;
33995 PyObject * obj1 = 0 ;
33996 char * kwnames[] = {
33997 (char *) "self",(char *) "sz", NULL
33998 };
33999
34000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34002 if (!SWIG_IsOK(res1)) {
34003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34004 }
34005 arg1 = reinterpret_cast< wxWindow * >(argp1);
34006 {
34007 arg2 = &temp2;
34008 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34009 }
34010 {
34011 PyThreadState* __tstate = wxPyBeginAllowThreads();
34012 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34013 wxPyEndAllowThreads(__tstate);
34014 if (PyErr_Occurred()) SWIG_fail;
34015 }
34016 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34017 return resultobj;
34018 fail:
34019 return NULL;
34020 }
34021
34022
34023 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34024 PyObject *resultobj = 0;
34025 wxWindow *arg1 = (wxWindow *) 0 ;
34026 wxPoint *arg2 = 0 ;
34027 wxPoint result;
34028 void *argp1 = 0 ;
34029 int res1 = 0 ;
34030 wxPoint temp2 ;
34031 PyObject * obj0 = 0 ;
34032 PyObject * obj1 = 0 ;
34033 char * kwnames[] = {
34034 (char *) "self",(char *) "pt", NULL
34035 };
34036
34037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34039 if (!SWIG_IsOK(res1)) {
34040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34041 }
34042 arg1 = reinterpret_cast< wxWindow * >(argp1);
34043 {
34044 arg2 = &temp2;
34045 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34046 }
34047 {
34048 PyThreadState* __tstate = wxPyBeginAllowThreads();
34049 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34050 wxPyEndAllowThreads(__tstate);
34051 if (PyErr_Occurred()) SWIG_fail;
34052 }
34053 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34054 return resultobj;
34055 fail:
34056 return NULL;
34057 }
34058
34059
34060 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34061 PyObject *resultobj = 0;
34062 wxWindow *arg1 = (wxWindow *) 0 ;
34063 wxSize *arg2 = 0 ;
34064 wxSize result;
34065 void *argp1 = 0 ;
34066 int res1 = 0 ;
34067 wxSize temp2 ;
34068 PyObject * obj0 = 0 ;
34069 PyObject * obj1 = 0 ;
34070 char * kwnames[] = {
34071 (char *) "self",(char *) "sz", NULL
34072 };
34073
34074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34076 if (!SWIG_IsOK(res1)) {
34077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34078 }
34079 arg1 = reinterpret_cast< wxWindow * >(argp1);
34080 {
34081 arg2 = &temp2;
34082 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34083 }
34084 {
34085 PyThreadState* __tstate = wxPyBeginAllowThreads();
34086 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34087 wxPyEndAllowThreads(__tstate);
34088 if (PyErr_Occurred()) SWIG_fail;
34089 }
34090 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34091 return resultobj;
34092 fail:
34093 return NULL;
34094 }
34095
34096
34097 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34098 PyObject *resultobj = 0;
34099 wxWindow *arg1 = (wxWindow *) 0 ;
34100 int arg2 ;
34101 int arg3 ;
34102 void *argp1 = 0 ;
34103 int res1 = 0 ;
34104 int val2 ;
34105 int ecode2 = 0 ;
34106 int val3 ;
34107 int ecode3 = 0 ;
34108 PyObject * obj0 = 0 ;
34109 PyObject * obj1 = 0 ;
34110 PyObject * obj2 = 0 ;
34111 char * kwnames[] = {
34112 (char *) "self",(char *) "x",(char *) "y", NULL
34113 };
34114
34115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34117 if (!SWIG_IsOK(res1)) {
34118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34119 }
34120 arg1 = reinterpret_cast< wxWindow * >(argp1);
34121 ecode2 = SWIG_AsVal_int(obj1, &val2);
34122 if (!SWIG_IsOK(ecode2)) {
34123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34124 }
34125 arg2 = static_cast< int >(val2);
34126 ecode3 = SWIG_AsVal_int(obj2, &val3);
34127 if (!SWIG_IsOK(ecode3)) {
34128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34129 }
34130 arg3 = static_cast< int >(val3);
34131 {
34132 PyThreadState* __tstate = wxPyBeginAllowThreads();
34133 (arg1)->WarpPointer(arg2,arg3);
34134 wxPyEndAllowThreads(__tstate);
34135 if (PyErr_Occurred()) SWIG_fail;
34136 }
34137 resultobj = SWIG_Py_Void();
34138 return resultobj;
34139 fail:
34140 return NULL;
34141 }
34142
34143
34144 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34145 PyObject *resultobj = 0;
34146 wxWindow *arg1 = (wxWindow *) 0 ;
34147 void *argp1 = 0 ;
34148 int res1 = 0 ;
34149 PyObject *swig_obj[1] ;
34150
34151 if (!args) SWIG_fail;
34152 swig_obj[0] = args;
34153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34154 if (!SWIG_IsOK(res1)) {
34155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34156 }
34157 arg1 = reinterpret_cast< wxWindow * >(argp1);
34158 {
34159 PyThreadState* __tstate = wxPyBeginAllowThreads();
34160 (arg1)->CaptureMouse();
34161 wxPyEndAllowThreads(__tstate);
34162 if (PyErr_Occurred()) SWIG_fail;
34163 }
34164 resultobj = SWIG_Py_Void();
34165 return resultobj;
34166 fail:
34167 return NULL;
34168 }
34169
34170
34171 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34172 PyObject *resultobj = 0;
34173 wxWindow *arg1 = (wxWindow *) 0 ;
34174 void *argp1 = 0 ;
34175 int res1 = 0 ;
34176 PyObject *swig_obj[1] ;
34177
34178 if (!args) SWIG_fail;
34179 swig_obj[0] = args;
34180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34181 if (!SWIG_IsOK(res1)) {
34182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34183 }
34184 arg1 = reinterpret_cast< wxWindow * >(argp1);
34185 {
34186 PyThreadState* __tstate = wxPyBeginAllowThreads();
34187 (arg1)->ReleaseMouse();
34188 wxPyEndAllowThreads(__tstate);
34189 if (PyErr_Occurred()) SWIG_fail;
34190 }
34191 resultobj = SWIG_Py_Void();
34192 return resultobj;
34193 fail:
34194 return NULL;
34195 }
34196
34197
34198 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34199 PyObject *resultobj = 0;
34200 wxWindow *result = 0 ;
34201
34202 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34203 {
34204 if (!wxPyCheckForApp()) SWIG_fail;
34205 PyThreadState* __tstate = wxPyBeginAllowThreads();
34206 result = (wxWindow *)wxWindow::GetCapture();
34207 wxPyEndAllowThreads(__tstate);
34208 if (PyErr_Occurred()) SWIG_fail;
34209 }
34210 {
34211 resultobj = wxPyMake_wxObject(result, 0);
34212 }
34213 return resultobj;
34214 fail:
34215 return NULL;
34216 }
34217
34218
34219 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34220 PyObject *resultobj = 0;
34221 wxWindow *arg1 = (wxWindow *) 0 ;
34222 bool result;
34223 void *argp1 = 0 ;
34224 int res1 = 0 ;
34225 PyObject *swig_obj[1] ;
34226
34227 if (!args) SWIG_fail;
34228 swig_obj[0] = args;
34229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34230 if (!SWIG_IsOK(res1)) {
34231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34232 }
34233 arg1 = reinterpret_cast< wxWindow * >(argp1);
34234 {
34235 PyThreadState* __tstate = wxPyBeginAllowThreads();
34236 result = (bool)((wxWindow const *)arg1)->HasCapture();
34237 wxPyEndAllowThreads(__tstate);
34238 if (PyErr_Occurred()) SWIG_fail;
34239 }
34240 {
34241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34242 }
34243 return resultobj;
34244 fail:
34245 return NULL;
34246 }
34247
34248
34249 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34250 PyObject *resultobj = 0;
34251 wxWindow *arg1 = (wxWindow *) 0 ;
34252 bool arg2 = (bool) true ;
34253 wxRect *arg3 = (wxRect *) NULL ;
34254 void *argp1 = 0 ;
34255 int res1 = 0 ;
34256 bool val2 ;
34257 int ecode2 = 0 ;
34258 void *argp3 = 0 ;
34259 int res3 = 0 ;
34260 PyObject * obj0 = 0 ;
34261 PyObject * obj1 = 0 ;
34262 PyObject * obj2 = 0 ;
34263 char * kwnames[] = {
34264 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34265 };
34266
34267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34269 if (!SWIG_IsOK(res1)) {
34270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34271 }
34272 arg1 = reinterpret_cast< wxWindow * >(argp1);
34273 if (obj1) {
34274 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34275 if (!SWIG_IsOK(ecode2)) {
34276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34277 }
34278 arg2 = static_cast< bool >(val2);
34279 }
34280 if (obj2) {
34281 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34282 if (!SWIG_IsOK(res3)) {
34283 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34284 }
34285 arg3 = reinterpret_cast< wxRect * >(argp3);
34286 }
34287 {
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34290 wxPyEndAllowThreads(__tstate);
34291 if (PyErr_Occurred()) SWIG_fail;
34292 }
34293 resultobj = SWIG_Py_Void();
34294 return resultobj;
34295 fail:
34296 return NULL;
34297 }
34298
34299
34300 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34301 PyObject *resultobj = 0;
34302 wxWindow *arg1 = (wxWindow *) 0 ;
34303 wxRect *arg2 = 0 ;
34304 bool arg3 = (bool) true ;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 wxRect temp2 ;
34308 bool val3 ;
34309 int ecode3 = 0 ;
34310 PyObject * obj0 = 0 ;
34311 PyObject * obj1 = 0 ;
34312 PyObject * obj2 = 0 ;
34313 char * kwnames[] = {
34314 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34315 };
34316
34317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34319 if (!SWIG_IsOK(res1)) {
34320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34321 }
34322 arg1 = reinterpret_cast< wxWindow * >(argp1);
34323 {
34324 arg2 = &temp2;
34325 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34326 }
34327 if (obj2) {
34328 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34329 if (!SWIG_IsOK(ecode3)) {
34330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34331 }
34332 arg3 = static_cast< bool >(val3);
34333 }
34334 {
34335 PyThreadState* __tstate = wxPyBeginAllowThreads();
34336 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34337 wxPyEndAllowThreads(__tstate);
34338 if (PyErr_Occurred()) SWIG_fail;
34339 }
34340 resultobj = SWIG_Py_Void();
34341 return resultobj;
34342 fail:
34343 return NULL;
34344 }
34345
34346
34347 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34348 PyObject *resultobj = 0;
34349 wxWindow *arg1 = (wxWindow *) 0 ;
34350 void *argp1 = 0 ;
34351 int res1 = 0 ;
34352 PyObject *swig_obj[1] ;
34353
34354 if (!args) SWIG_fail;
34355 swig_obj[0] = args;
34356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34357 if (!SWIG_IsOK(res1)) {
34358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34359 }
34360 arg1 = reinterpret_cast< wxWindow * >(argp1);
34361 {
34362 PyThreadState* __tstate = wxPyBeginAllowThreads();
34363 (arg1)->Update();
34364 wxPyEndAllowThreads(__tstate);
34365 if (PyErr_Occurred()) SWIG_fail;
34366 }
34367 resultobj = SWIG_Py_Void();
34368 return resultobj;
34369 fail:
34370 return NULL;
34371 }
34372
34373
34374 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34375 PyObject *resultobj = 0;
34376 wxWindow *arg1 = (wxWindow *) 0 ;
34377 void *argp1 = 0 ;
34378 int res1 = 0 ;
34379 PyObject *swig_obj[1] ;
34380
34381 if (!args) SWIG_fail;
34382 swig_obj[0] = args;
34383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34384 if (!SWIG_IsOK(res1)) {
34385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34386 }
34387 arg1 = reinterpret_cast< wxWindow * >(argp1);
34388 {
34389 PyThreadState* __tstate = wxPyBeginAllowThreads();
34390 (arg1)->ClearBackground();
34391 wxPyEndAllowThreads(__tstate);
34392 if (PyErr_Occurred()) SWIG_fail;
34393 }
34394 resultobj = SWIG_Py_Void();
34395 return resultobj;
34396 fail:
34397 return NULL;
34398 }
34399
34400
34401 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34402 PyObject *resultobj = 0;
34403 wxWindow *arg1 = (wxWindow *) 0 ;
34404 void *argp1 = 0 ;
34405 int res1 = 0 ;
34406 PyObject *swig_obj[1] ;
34407
34408 if (!args) SWIG_fail;
34409 swig_obj[0] = args;
34410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34411 if (!SWIG_IsOK(res1)) {
34412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34413 }
34414 arg1 = reinterpret_cast< wxWindow * >(argp1);
34415 {
34416 PyThreadState* __tstate = wxPyBeginAllowThreads();
34417 (arg1)->Freeze();
34418 wxPyEndAllowThreads(__tstate);
34419 if (PyErr_Occurred()) SWIG_fail;
34420 }
34421 resultobj = SWIG_Py_Void();
34422 return resultobj;
34423 fail:
34424 return NULL;
34425 }
34426
34427
34428 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34429 PyObject *resultobj = 0;
34430 wxWindow *arg1 = (wxWindow *) 0 ;
34431 void *argp1 = 0 ;
34432 int res1 = 0 ;
34433 PyObject *swig_obj[1] ;
34434
34435 if (!args) SWIG_fail;
34436 swig_obj[0] = args;
34437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34438 if (!SWIG_IsOK(res1)) {
34439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34440 }
34441 arg1 = reinterpret_cast< wxWindow * >(argp1);
34442 {
34443 PyThreadState* __tstate = wxPyBeginAllowThreads();
34444 (arg1)->Thaw();
34445 wxPyEndAllowThreads(__tstate);
34446 if (PyErr_Occurred()) SWIG_fail;
34447 }
34448 resultobj = SWIG_Py_Void();
34449 return resultobj;
34450 fail:
34451 return NULL;
34452 }
34453
34454
34455 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34456 PyObject *resultobj = 0;
34457 wxWindow *arg1 = (wxWindow *) 0 ;
34458 wxDC *arg2 = 0 ;
34459 void *argp1 = 0 ;
34460 int res1 = 0 ;
34461 void *argp2 = 0 ;
34462 int res2 = 0 ;
34463 PyObject * obj0 = 0 ;
34464 PyObject * obj1 = 0 ;
34465 char * kwnames[] = {
34466 (char *) "self",(char *) "dc", NULL
34467 };
34468
34469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34471 if (!SWIG_IsOK(res1)) {
34472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34473 }
34474 arg1 = reinterpret_cast< wxWindow * >(argp1);
34475 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34476 if (!SWIG_IsOK(res2)) {
34477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34478 }
34479 if (!argp2) {
34480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34481 }
34482 arg2 = reinterpret_cast< wxDC * >(argp2);
34483 {
34484 PyThreadState* __tstate = wxPyBeginAllowThreads();
34485 (arg1)->PrepareDC(*arg2);
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 resultobj = SWIG_Py_Void();
34490 return resultobj;
34491 fail:
34492 return NULL;
34493 }
34494
34495
34496 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34497 PyObject *resultobj = 0;
34498 wxWindow *arg1 = (wxWindow *) 0 ;
34499 wxRegion *result = 0 ;
34500 void *argp1 = 0 ;
34501 int res1 = 0 ;
34502 PyObject *swig_obj[1] ;
34503
34504 if (!args) SWIG_fail;
34505 swig_obj[0] = args;
34506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34507 if (!SWIG_IsOK(res1)) {
34508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34509 }
34510 arg1 = reinterpret_cast< wxWindow * >(argp1);
34511 {
34512 PyThreadState* __tstate = wxPyBeginAllowThreads();
34513 {
34514 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34515 result = (wxRegion *) &_result_ref;
34516 }
34517 wxPyEndAllowThreads(__tstate);
34518 if (PyErr_Occurred()) SWIG_fail;
34519 }
34520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34521 return resultobj;
34522 fail:
34523 return NULL;
34524 }
34525
34526
34527 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34528 PyObject *resultobj = 0;
34529 wxWindow *arg1 = (wxWindow *) 0 ;
34530 wxRect result;
34531 void *argp1 = 0 ;
34532 int res1 = 0 ;
34533 PyObject *swig_obj[1] ;
34534
34535 if (!args) SWIG_fail;
34536 swig_obj[0] = args;
34537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34538 if (!SWIG_IsOK(res1)) {
34539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34540 }
34541 arg1 = reinterpret_cast< wxWindow * >(argp1);
34542 {
34543 PyThreadState* __tstate = wxPyBeginAllowThreads();
34544 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34545 wxPyEndAllowThreads(__tstate);
34546 if (PyErr_Occurred()) SWIG_fail;
34547 }
34548 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34549 return resultobj;
34550 fail:
34551 return NULL;
34552 }
34553
34554
34555 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34556 PyObject *resultobj = 0;
34557 wxWindow *arg1 = (wxWindow *) 0 ;
34558 int arg2 ;
34559 int arg3 ;
34560 int arg4 = (int) 1 ;
34561 int arg5 = (int) 1 ;
34562 bool result;
34563 void *argp1 = 0 ;
34564 int res1 = 0 ;
34565 int val2 ;
34566 int ecode2 = 0 ;
34567 int val3 ;
34568 int ecode3 = 0 ;
34569 int val4 ;
34570 int ecode4 = 0 ;
34571 int val5 ;
34572 int ecode5 = 0 ;
34573 PyObject * obj0 = 0 ;
34574 PyObject * obj1 = 0 ;
34575 PyObject * obj2 = 0 ;
34576 PyObject * obj3 = 0 ;
34577 PyObject * obj4 = 0 ;
34578 char * kwnames[] = {
34579 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34580 };
34581
34582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34584 if (!SWIG_IsOK(res1)) {
34585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34586 }
34587 arg1 = reinterpret_cast< wxWindow * >(argp1);
34588 ecode2 = SWIG_AsVal_int(obj1, &val2);
34589 if (!SWIG_IsOK(ecode2)) {
34590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34591 }
34592 arg2 = static_cast< int >(val2);
34593 ecode3 = SWIG_AsVal_int(obj2, &val3);
34594 if (!SWIG_IsOK(ecode3)) {
34595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34596 }
34597 arg3 = static_cast< int >(val3);
34598 if (obj3) {
34599 ecode4 = SWIG_AsVal_int(obj3, &val4);
34600 if (!SWIG_IsOK(ecode4)) {
34601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34602 }
34603 arg4 = static_cast< int >(val4);
34604 }
34605 if (obj4) {
34606 ecode5 = SWIG_AsVal_int(obj4, &val5);
34607 if (!SWIG_IsOK(ecode5)) {
34608 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34609 }
34610 arg5 = static_cast< int >(val5);
34611 }
34612 {
34613 PyThreadState* __tstate = wxPyBeginAllowThreads();
34614 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34615 wxPyEndAllowThreads(__tstate);
34616 if (PyErr_Occurred()) SWIG_fail;
34617 }
34618 {
34619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34620 }
34621 return resultobj;
34622 fail:
34623 return NULL;
34624 }
34625
34626
34627 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34628 PyObject *resultobj = 0;
34629 wxWindow *arg1 = (wxWindow *) 0 ;
34630 wxPoint *arg2 = 0 ;
34631 bool result;
34632 void *argp1 = 0 ;
34633 int res1 = 0 ;
34634 wxPoint temp2 ;
34635 PyObject * obj0 = 0 ;
34636 PyObject * obj1 = 0 ;
34637 char * kwnames[] = {
34638 (char *) "self",(char *) "pt", NULL
34639 };
34640
34641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34643 if (!SWIG_IsOK(res1)) {
34644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34645 }
34646 arg1 = reinterpret_cast< wxWindow * >(argp1);
34647 {
34648 arg2 = &temp2;
34649 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34650 }
34651 {
34652 PyThreadState* __tstate = wxPyBeginAllowThreads();
34653 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 {
34658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34659 }
34660 return resultobj;
34661 fail:
34662 return NULL;
34663 }
34664
34665
34666 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34667 PyObject *resultobj = 0;
34668 wxWindow *arg1 = (wxWindow *) 0 ;
34669 wxRect *arg2 = 0 ;
34670 bool result;
34671 void *argp1 = 0 ;
34672 int res1 = 0 ;
34673 wxRect temp2 ;
34674 PyObject * obj0 = 0 ;
34675 PyObject * obj1 = 0 ;
34676 char * kwnames[] = {
34677 (char *) "self",(char *) "rect", NULL
34678 };
34679
34680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34682 if (!SWIG_IsOK(res1)) {
34683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34684 }
34685 arg1 = reinterpret_cast< wxWindow * >(argp1);
34686 {
34687 arg2 = &temp2;
34688 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34689 }
34690 {
34691 PyThreadState* __tstate = wxPyBeginAllowThreads();
34692 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34693 wxPyEndAllowThreads(__tstate);
34694 if (PyErr_Occurred()) SWIG_fail;
34695 }
34696 {
34697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34698 }
34699 return resultobj;
34700 fail:
34701 return NULL;
34702 }
34703
34704
34705 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34706 PyObject *resultobj = 0;
34707 wxWindow *arg1 = (wxWindow *) 0 ;
34708 SwigValueWrapper<wxVisualAttributes > result;
34709 void *argp1 = 0 ;
34710 int res1 = 0 ;
34711 PyObject *swig_obj[1] ;
34712
34713 if (!args) SWIG_fail;
34714 swig_obj[0] = args;
34715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34716 if (!SWIG_IsOK(res1)) {
34717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34718 }
34719 arg1 = reinterpret_cast< wxWindow * >(argp1);
34720 {
34721 PyThreadState* __tstate = wxPyBeginAllowThreads();
34722 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34723 wxPyEndAllowThreads(__tstate);
34724 if (PyErr_Occurred()) SWIG_fail;
34725 }
34726 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34727 return resultobj;
34728 fail:
34729 return NULL;
34730 }
34731
34732
34733 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34734 PyObject *resultobj = 0;
34735 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34736 SwigValueWrapper<wxVisualAttributes > result;
34737 int val1 ;
34738 int ecode1 = 0 ;
34739 PyObject * obj0 = 0 ;
34740 char * kwnames[] = {
34741 (char *) "variant", NULL
34742 };
34743
34744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34745 if (obj0) {
34746 ecode1 = SWIG_AsVal_int(obj0, &val1);
34747 if (!SWIG_IsOK(ecode1)) {
34748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34749 }
34750 arg1 = static_cast< wxWindowVariant >(val1);
34751 }
34752 {
34753 if (!wxPyCheckForApp()) SWIG_fail;
34754 PyThreadState* __tstate = wxPyBeginAllowThreads();
34755 result = wxWindow::GetClassDefaultAttributes(arg1);
34756 wxPyEndAllowThreads(__tstate);
34757 if (PyErr_Occurred()) SWIG_fail;
34758 }
34759 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34760 return resultobj;
34761 fail:
34762 return NULL;
34763 }
34764
34765
34766 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34767 PyObject *resultobj = 0;
34768 wxWindow *arg1 = (wxWindow *) 0 ;
34769 wxColour *arg2 = 0 ;
34770 bool result;
34771 void *argp1 = 0 ;
34772 int res1 = 0 ;
34773 wxColour temp2 ;
34774 PyObject * obj0 = 0 ;
34775 PyObject * obj1 = 0 ;
34776 char * kwnames[] = {
34777 (char *) "self",(char *) "colour", NULL
34778 };
34779
34780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34782 if (!SWIG_IsOK(res1)) {
34783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34784 }
34785 arg1 = reinterpret_cast< wxWindow * >(argp1);
34786 {
34787 arg2 = &temp2;
34788 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34789 }
34790 {
34791 PyThreadState* __tstate = wxPyBeginAllowThreads();
34792 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34793 wxPyEndAllowThreads(__tstate);
34794 if (PyErr_Occurred()) SWIG_fail;
34795 }
34796 {
34797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34798 }
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34806 PyObject *resultobj = 0;
34807 wxWindow *arg1 = (wxWindow *) 0 ;
34808 wxColour *arg2 = 0 ;
34809 void *argp1 = 0 ;
34810 int res1 = 0 ;
34811 wxColour temp2 ;
34812 PyObject * obj0 = 0 ;
34813 PyObject * obj1 = 0 ;
34814 char * kwnames[] = {
34815 (char *) "self",(char *) "colour", NULL
34816 };
34817
34818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34820 if (!SWIG_IsOK(res1)) {
34821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34822 }
34823 arg1 = reinterpret_cast< wxWindow * >(argp1);
34824 {
34825 arg2 = &temp2;
34826 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34827 }
34828 {
34829 PyThreadState* __tstate = wxPyBeginAllowThreads();
34830 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34831 wxPyEndAllowThreads(__tstate);
34832 if (PyErr_Occurred()) SWIG_fail;
34833 }
34834 resultobj = SWIG_Py_Void();
34835 return resultobj;
34836 fail:
34837 return NULL;
34838 }
34839
34840
34841 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34842 PyObject *resultobj = 0;
34843 wxWindow *arg1 = (wxWindow *) 0 ;
34844 wxColour *arg2 = 0 ;
34845 bool result;
34846 void *argp1 = 0 ;
34847 int res1 = 0 ;
34848 wxColour temp2 ;
34849 PyObject * obj0 = 0 ;
34850 PyObject * obj1 = 0 ;
34851 char * kwnames[] = {
34852 (char *) "self",(char *) "colour", NULL
34853 };
34854
34855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34857 if (!SWIG_IsOK(res1)) {
34858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34859 }
34860 arg1 = reinterpret_cast< wxWindow * >(argp1);
34861 {
34862 arg2 = &temp2;
34863 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34864 }
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 {
34872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34873 }
34874 return resultobj;
34875 fail:
34876 return NULL;
34877 }
34878
34879
34880 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34881 PyObject *resultobj = 0;
34882 wxWindow *arg1 = (wxWindow *) 0 ;
34883 wxColour *arg2 = 0 ;
34884 void *argp1 = 0 ;
34885 int res1 = 0 ;
34886 wxColour temp2 ;
34887 PyObject * obj0 = 0 ;
34888 PyObject * obj1 = 0 ;
34889 char * kwnames[] = {
34890 (char *) "self",(char *) "colour", NULL
34891 };
34892
34893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34895 if (!SWIG_IsOK(res1)) {
34896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34897 }
34898 arg1 = reinterpret_cast< wxWindow * >(argp1);
34899 {
34900 arg2 = &temp2;
34901 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34902 }
34903 {
34904 PyThreadState* __tstate = wxPyBeginAllowThreads();
34905 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34906 wxPyEndAllowThreads(__tstate);
34907 if (PyErr_Occurred()) SWIG_fail;
34908 }
34909 resultobj = SWIG_Py_Void();
34910 return resultobj;
34911 fail:
34912 return NULL;
34913 }
34914
34915
34916 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34917 PyObject *resultobj = 0;
34918 wxWindow *arg1 = (wxWindow *) 0 ;
34919 wxColour result;
34920 void *argp1 = 0 ;
34921 int res1 = 0 ;
34922 PyObject *swig_obj[1] ;
34923
34924 if (!args) SWIG_fail;
34925 swig_obj[0] = args;
34926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34927 if (!SWIG_IsOK(res1)) {
34928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34929 }
34930 arg1 = reinterpret_cast< wxWindow * >(argp1);
34931 {
34932 PyThreadState* __tstate = wxPyBeginAllowThreads();
34933 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34934 wxPyEndAllowThreads(__tstate);
34935 if (PyErr_Occurred()) SWIG_fail;
34936 }
34937 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34938 return resultobj;
34939 fail:
34940 return NULL;
34941 }
34942
34943
34944 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34945 PyObject *resultobj = 0;
34946 wxWindow *arg1 = (wxWindow *) 0 ;
34947 wxColour result;
34948 void *argp1 = 0 ;
34949 int res1 = 0 ;
34950 PyObject *swig_obj[1] ;
34951
34952 if (!args) SWIG_fail;
34953 swig_obj[0] = args;
34954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34955 if (!SWIG_IsOK(res1)) {
34956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34957 }
34958 arg1 = reinterpret_cast< wxWindow * >(argp1);
34959 {
34960 PyThreadState* __tstate = wxPyBeginAllowThreads();
34961 result = ((wxWindow const *)arg1)->GetForegroundColour();
34962 wxPyEndAllowThreads(__tstate);
34963 if (PyErr_Occurred()) SWIG_fail;
34964 }
34965 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34966 return resultobj;
34967 fail:
34968 return NULL;
34969 }
34970
34971
34972 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34973 PyObject *resultobj = 0;
34974 wxWindow *arg1 = (wxWindow *) 0 ;
34975 bool result;
34976 void *argp1 = 0 ;
34977 int res1 = 0 ;
34978 PyObject *swig_obj[1] ;
34979
34980 if (!args) SWIG_fail;
34981 swig_obj[0] = args;
34982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34983 if (!SWIG_IsOK(res1)) {
34984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34985 }
34986 arg1 = reinterpret_cast< wxWindow * >(argp1);
34987 {
34988 PyThreadState* __tstate = wxPyBeginAllowThreads();
34989 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34990 wxPyEndAllowThreads(__tstate);
34991 if (PyErr_Occurred()) SWIG_fail;
34992 }
34993 {
34994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34995 }
34996 return resultobj;
34997 fail:
34998 return NULL;
34999 }
35000
35001
35002 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35003 PyObject *resultobj = 0;
35004 wxWindow *arg1 = (wxWindow *) 0 ;
35005 bool result;
35006 void *argp1 = 0 ;
35007 int res1 = 0 ;
35008 PyObject *swig_obj[1] ;
35009
35010 if (!args) SWIG_fail;
35011 swig_obj[0] = args;
35012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35013 if (!SWIG_IsOK(res1)) {
35014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35015 }
35016 arg1 = reinterpret_cast< wxWindow * >(argp1);
35017 {
35018 PyThreadState* __tstate = wxPyBeginAllowThreads();
35019 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35020 wxPyEndAllowThreads(__tstate);
35021 if (PyErr_Occurred()) SWIG_fail;
35022 }
35023 {
35024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35025 }
35026 return resultobj;
35027 fail:
35028 return NULL;
35029 }
35030
35031
35032 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35033 PyObject *resultobj = 0;
35034 wxWindow *arg1 = (wxWindow *) 0 ;
35035 wxBackgroundStyle arg2 ;
35036 bool result;
35037 void *argp1 = 0 ;
35038 int res1 = 0 ;
35039 int val2 ;
35040 int ecode2 = 0 ;
35041 PyObject * obj0 = 0 ;
35042 PyObject * obj1 = 0 ;
35043 char * kwnames[] = {
35044 (char *) "self",(char *) "style", NULL
35045 };
35046
35047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35049 if (!SWIG_IsOK(res1)) {
35050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35051 }
35052 arg1 = reinterpret_cast< wxWindow * >(argp1);
35053 ecode2 = SWIG_AsVal_int(obj1, &val2);
35054 if (!SWIG_IsOK(ecode2)) {
35055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35056 }
35057 arg2 = static_cast< wxBackgroundStyle >(val2);
35058 {
35059 PyThreadState* __tstate = wxPyBeginAllowThreads();
35060 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35061 wxPyEndAllowThreads(__tstate);
35062 if (PyErr_Occurred()) SWIG_fail;
35063 }
35064 {
35065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35066 }
35067 return resultobj;
35068 fail:
35069 return NULL;
35070 }
35071
35072
35073 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35074 PyObject *resultobj = 0;
35075 wxWindow *arg1 = (wxWindow *) 0 ;
35076 wxBackgroundStyle result;
35077 void *argp1 = 0 ;
35078 int res1 = 0 ;
35079 PyObject *swig_obj[1] ;
35080
35081 if (!args) SWIG_fail;
35082 swig_obj[0] = args;
35083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35084 if (!SWIG_IsOK(res1)) {
35085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35086 }
35087 arg1 = reinterpret_cast< wxWindow * >(argp1);
35088 {
35089 PyThreadState* __tstate = wxPyBeginAllowThreads();
35090 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35091 wxPyEndAllowThreads(__tstate);
35092 if (PyErr_Occurred()) SWIG_fail;
35093 }
35094 resultobj = SWIG_From_int(static_cast< int >(result));
35095 return resultobj;
35096 fail:
35097 return NULL;
35098 }
35099
35100
35101 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35102 PyObject *resultobj = 0;
35103 wxWindow *arg1 = (wxWindow *) 0 ;
35104 bool result;
35105 void *argp1 = 0 ;
35106 int res1 = 0 ;
35107 PyObject *swig_obj[1] ;
35108
35109 if (!args) SWIG_fail;
35110 swig_obj[0] = args;
35111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35112 if (!SWIG_IsOK(res1)) {
35113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35114 }
35115 arg1 = reinterpret_cast< wxWindow * >(argp1);
35116 {
35117 PyThreadState* __tstate = wxPyBeginAllowThreads();
35118 result = (bool)(arg1)->HasTransparentBackground();
35119 wxPyEndAllowThreads(__tstate);
35120 if (PyErr_Occurred()) SWIG_fail;
35121 }
35122 {
35123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35124 }
35125 return resultobj;
35126 fail:
35127 return NULL;
35128 }
35129
35130
35131 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35132 PyObject *resultobj = 0;
35133 wxWindow *arg1 = (wxWindow *) 0 ;
35134 wxCursor *arg2 = 0 ;
35135 bool result;
35136 void *argp1 = 0 ;
35137 int res1 = 0 ;
35138 void *argp2 = 0 ;
35139 int res2 = 0 ;
35140 PyObject * obj0 = 0 ;
35141 PyObject * obj1 = 0 ;
35142 char * kwnames[] = {
35143 (char *) "self",(char *) "cursor", NULL
35144 };
35145
35146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35148 if (!SWIG_IsOK(res1)) {
35149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35150 }
35151 arg1 = reinterpret_cast< wxWindow * >(argp1);
35152 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35153 if (!SWIG_IsOK(res2)) {
35154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35155 }
35156 if (!argp2) {
35157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35158 }
35159 arg2 = reinterpret_cast< wxCursor * >(argp2);
35160 {
35161 PyThreadState* __tstate = wxPyBeginAllowThreads();
35162 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35163 wxPyEndAllowThreads(__tstate);
35164 if (PyErr_Occurred()) SWIG_fail;
35165 }
35166 {
35167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35168 }
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxWindow *arg1 = (wxWindow *) 0 ;
35178 wxCursor result;
35179 void *argp1 = 0 ;
35180 int res1 = 0 ;
35181 PyObject *swig_obj[1] ;
35182
35183 if (!args) SWIG_fail;
35184 swig_obj[0] = args;
35185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35186 if (!SWIG_IsOK(res1)) {
35187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35188 }
35189 arg1 = reinterpret_cast< wxWindow * >(argp1);
35190 {
35191 PyThreadState* __tstate = wxPyBeginAllowThreads();
35192 result = (arg1)->GetCursor();
35193 wxPyEndAllowThreads(__tstate);
35194 if (PyErr_Occurred()) SWIG_fail;
35195 }
35196 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35197 return resultobj;
35198 fail:
35199 return NULL;
35200 }
35201
35202
35203 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35204 PyObject *resultobj = 0;
35205 wxWindow *arg1 = (wxWindow *) 0 ;
35206 wxFont *arg2 = 0 ;
35207 bool result;
35208 void *argp1 = 0 ;
35209 int res1 = 0 ;
35210 void *argp2 = 0 ;
35211 int res2 = 0 ;
35212 PyObject * obj0 = 0 ;
35213 PyObject * obj1 = 0 ;
35214 char * kwnames[] = {
35215 (char *) "self",(char *) "font", NULL
35216 };
35217
35218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35220 if (!SWIG_IsOK(res1)) {
35221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35222 }
35223 arg1 = reinterpret_cast< wxWindow * >(argp1);
35224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35225 if (!SWIG_IsOK(res2)) {
35226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35227 }
35228 if (!argp2) {
35229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35230 }
35231 arg2 = reinterpret_cast< wxFont * >(argp2);
35232 {
35233 PyThreadState* __tstate = wxPyBeginAllowThreads();
35234 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35235 wxPyEndAllowThreads(__tstate);
35236 if (PyErr_Occurred()) SWIG_fail;
35237 }
35238 {
35239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35240 }
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35248 PyObject *resultobj = 0;
35249 wxWindow *arg1 = (wxWindow *) 0 ;
35250 wxFont *arg2 = 0 ;
35251 void *argp1 = 0 ;
35252 int res1 = 0 ;
35253 void *argp2 = 0 ;
35254 int res2 = 0 ;
35255 PyObject * obj0 = 0 ;
35256 PyObject * obj1 = 0 ;
35257 char * kwnames[] = {
35258 (char *) "self",(char *) "font", NULL
35259 };
35260
35261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35263 if (!SWIG_IsOK(res1)) {
35264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35265 }
35266 arg1 = reinterpret_cast< wxWindow * >(argp1);
35267 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35268 if (!SWIG_IsOK(res2)) {
35269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35270 }
35271 if (!argp2) {
35272 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35273 }
35274 arg2 = reinterpret_cast< wxFont * >(argp2);
35275 {
35276 PyThreadState* __tstate = wxPyBeginAllowThreads();
35277 (arg1)->SetOwnFont((wxFont const &)*arg2);
35278 wxPyEndAllowThreads(__tstate);
35279 if (PyErr_Occurred()) SWIG_fail;
35280 }
35281 resultobj = SWIG_Py_Void();
35282 return resultobj;
35283 fail:
35284 return NULL;
35285 }
35286
35287
35288 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35289 PyObject *resultobj = 0;
35290 wxWindow *arg1 = (wxWindow *) 0 ;
35291 wxFont result;
35292 void *argp1 = 0 ;
35293 int res1 = 0 ;
35294 PyObject *swig_obj[1] ;
35295
35296 if (!args) SWIG_fail;
35297 swig_obj[0] = args;
35298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35299 if (!SWIG_IsOK(res1)) {
35300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35301 }
35302 arg1 = reinterpret_cast< wxWindow * >(argp1);
35303 {
35304 PyThreadState* __tstate = wxPyBeginAllowThreads();
35305 result = (arg1)->GetFont();
35306 wxPyEndAllowThreads(__tstate);
35307 if (PyErr_Occurred()) SWIG_fail;
35308 }
35309 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35310 return resultobj;
35311 fail:
35312 return NULL;
35313 }
35314
35315
35316 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35317 PyObject *resultobj = 0;
35318 wxWindow *arg1 = (wxWindow *) 0 ;
35319 wxCaret *arg2 = (wxCaret *) 0 ;
35320 void *argp1 = 0 ;
35321 int res1 = 0 ;
35322 int res2 = 0 ;
35323 PyObject * obj0 = 0 ;
35324 PyObject * obj1 = 0 ;
35325 char * kwnames[] = {
35326 (char *) "self",(char *) "caret", NULL
35327 };
35328
35329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35331 if (!SWIG_IsOK(res1)) {
35332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35333 }
35334 arg1 = reinterpret_cast< wxWindow * >(argp1);
35335 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35336 if (!SWIG_IsOK(res2)) {
35337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35338 }
35339 {
35340 PyThreadState* __tstate = wxPyBeginAllowThreads();
35341 (arg1)->SetCaret(arg2);
35342 wxPyEndAllowThreads(__tstate);
35343 if (PyErr_Occurred()) SWIG_fail;
35344 }
35345 resultobj = SWIG_Py_Void();
35346 return resultobj;
35347 fail:
35348 return NULL;
35349 }
35350
35351
35352 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35353 PyObject *resultobj = 0;
35354 wxWindow *arg1 = (wxWindow *) 0 ;
35355 wxCaret *result = 0 ;
35356 void *argp1 = 0 ;
35357 int res1 = 0 ;
35358 PyObject *swig_obj[1] ;
35359
35360 if (!args) SWIG_fail;
35361 swig_obj[0] = args;
35362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35363 if (!SWIG_IsOK(res1)) {
35364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35365 }
35366 arg1 = reinterpret_cast< wxWindow * >(argp1);
35367 {
35368 PyThreadState* __tstate = wxPyBeginAllowThreads();
35369 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35370 wxPyEndAllowThreads(__tstate);
35371 if (PyErr_Occurred()) SWIG_fail;
35372 }
35373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35374 return resultobj;
35375 fail:
35376 return NULL;
35377 }
35378
35379
35380 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35381 PyObject *resultobj = 0;
35382 wxWindow *arg1 = (wxWindow *) 0 ;
35383 int result;
35384 void *argp1 = 0 ;
35385 int res1 = 0 ;
35386 PyObject *swig_obj[1] ;
35387
35388 if (!args) SWIG_fail;
35389 swig_obj[0] = args;
35390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35391 if (!SWIG_IsOK(res1)) {
35392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35393 }
35394 arg1 = reinterpret_cast< wxWindow * >(argp1);
35395 {
35396 PyThreadState* __tstate = wxPyBeginAllowThreads();
35397 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35398 wxPyEndAllowThreads(__tstate);
35399 if (PyErr_Occurred()) SWIG_fail;
35400 }
35401 resultobj = SWIG_From_int(static_cast< int >(result));
35402 return resultobj;
35403 fail:
35404 return NULL;
35405 }
35406
35407
35408 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35409 PyObject *resultobj = 0;
35410 wxWindow *arg1 = (wxWindow *) 0 ;
35411 int result;
35412 void *argp1 = 0 ;
35413 int res1 = 0 ;
35414 PyObject *swig_obj[1] ;
35415
35416 if (!args) SWIG_fail;
35417 swig_obj[0] = args;
35418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35419 if (!SWIG_IsOK(res1)) {
35420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35421 }
35422 arg1 = reinterpret_cast< wxWindow * >(argp1);
35423 {
35424 PyThreadState* __tstate = wxPyBeginAllowThreads();
35425 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 resultobj = SWIG_From_int(static_cast< int >(result));
35430 return resultobj;
35431 fail:
35432 return NULL;
35433 }
35434
35435
35436 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35437 PyObject *resultobj = 0;
35438 wxWindow *arg1 = (wxWindow *) 0 ;
35439 wxString *arg2 = 0 ;
35440 int *arg3 = (int *) 0 ;
35441 int *arg4 = (int *) 0 ;
35442 void *argp1 = 0 ;
35443 int res1 = 0 ;
35444 bool temp2 = false ;
35445 int temp3 ;
35446 int res3 = SWIG_TMPOBJ ;
35447 int temp4 ;
35448 int res4 = SWIG_TMPOBJ ;
35449 PyObject * obj0 = 0 ;
35450 PyObject * obj1 = 0 ;
35451 char * kwnames[] = {
35452 (char *) "self",(char *) "string", NULL
35453 };
35454
35455 arg3 = &temp3;
35456 arg4 = &temp4;
35457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35459 if (!SWIG_IsOK(res1)) {
35460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35461 }
35462 arg1 = reinterpret_cast< wxWindow * >(argp1);
35463 {
35464 arg2 = wxString_in_helper(obj1);
35465 if (arg2 == NULL) SWIG_fail;
35466 temp2 = true;
35467 }
35468 {
35469 PyThreadState* __tstate = wxPyBeginAllowThreads();
35470 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35471 wxPyEndAllowThreads(__tstate);
35472 if (PyErr_Occurred()) SWIG_fail;
35473 }
35474 resultobj = SWIG_Py_Void();
35475 if (SWIG_IsTmpObj(res3)) {
35476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35477 } else {
35478 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35480 }
35481 if (SWIG_IsTmpObj(res4)) {
35482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35483 } else {
35484 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35486 }
35487 {
35488 if (temp2)
35489 delete arg2;
35490 }
35491 return resultobj;
35492 fail:
35493 {
35494 if (temp2)
35495 delete arg2;
35496 }
35497 return NULL;
35498 }
35499
35500
35501 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35502 PyObject *resultobj = 0;
35503 wxWindow *arg1 = (wxWindow *) 0 ;
35504 wxString *arg2 = 0 ;
35505 int *arg3 = (int *) 0 ;
35506 int *arg4 = (int *) 0 ;
35507 int *arg5 = (int *) 0 ;
35508 int *arg6 = (int *) 0 ;
35509 wxFont *arg7 = (wxFont *) NULL ;
35510 void *argp1 = 0 ;
35511 int res1 = 0 ;
35512 bool temp2 = false ;
35513 int temp3 ;
35514 int res3 = SWIG_TMPOBJ ;
35515 int temp4 ;
35516 int res4 = SWIG_TMPOBJ ;
35517 int temp5 ;
35518 int res5 = SWIG_TMPOBJ ;
35519 int temp6 ;
35520 int res6 = SWIG_TMPOBJ ;
35521 void *argp7 = 0 ;
35522 int res7 = 0 ;
35523 PyObject * obj0 = 0 ;
35524 PyObject * obj1 = 0 ;
35525 PyObject * obj2 = 0 ;
35526 char * kwnames[] = {
35527 (char *) "self",(char *) "string",(char *) "font", NULL
35528 };
35529
35530 arg3 = &temp3;
35531 arg4 = &temp4;
35532 arg5 = &temp5;
35533 arg6 = &temp6;
35534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35536 if (!SWIG_IsOK(res1)) {
35537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35538 }
35539 arg1 = reinterpret_cast< wxWindow * >(argp1);
35540 {
35541 arg2 = wxString_in_helper(obj1);
35542 if (arg2 == NULL) SWIG_fail;
35543 temp2 = true;
35544 }
35545 if (obj2) {
35546 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35547 if (!SWIG_IsOK(res7)) {
35548 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35549 }
35550 arg7 = reinterpret_cast< wxFont * >(argp7);
35551 }
35552 {
35553 PyThreadState* __tstate = wxPyBeginAllowThreads();
35554 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35555 wxPyEndAllowThreads(__tstate);
35556 if (PyErr_Occurred()) SWIG_fail;
35557 }
35558 resultobj = SWIG_Py_Void();
35559 if (SWIG_IsTmpObj(res3)) {
35560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35561 } else {
35562 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35564 }
35565 if (SWIG_IsTmpObj(res4)) {
35566 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35567 } else {
35568 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35569 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35570 }
35571 if (SWIG_IsTmpObj(res5)) {
35572 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35573 } else {
35574 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35575 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35576 }
35577 if (SWIG_IsTmpObj(res6)) {
35578 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35579 } else {
35580 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35581 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35582 }
35583 {
35584 if (temp2)
35585 delete arg2;
35586 }
35587 return resultobj;
35588 fail:
35589 {
35590 if (temp2)
35591 delete arg2;
35592 }
35593 return NULL;
35594 }
35595
35596
35597 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35598 PyObject *resultobj = 0;
35599 wxWindow *arg1 = (wxWindow *) 0 ;
35600 int *arg2 = (int *) 0 ;
35601 int *arg3 = (int *) 0 ;
35602 void *argp1 = 0 ;
35603 int res1 = 0 ;
35604 int temp2 ;
35605 int res2 = 0 ;
35606 int temp3 ;
35607 int res3 = 0 ;
35608 PyObject * obj0 = 0 ;
35609 PyObject * obj1 = 0 ;
35610 PyObject * obj2 = 0 ;
35611 char * kwnames[] = {
35612 (char *) "self",(char *) "x",(char *) "y", NULL
35613 };
35614
35615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35617 if (!SWIG_IsOK(res1)) {
35618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35619 }
35620 arg1 = reinterpret_cast< wxWindow * >(argp1);
35621 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35622 int val;
35623 int ecode = SWIG_AsVal_int(obj1, &val);
35624 if (!SWIG_IsOK(ecode)) {
35625 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35626 }
35627 temp2 = static_cast< int >(val);
35628 arg2 = &temp2;
35629 res2 = SWIG_AddTmpMask(ecode);
35630 }
35631 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35632 int val;
35633 int ecode = SWIG_AsVal_int(obj2, &val);
35634 if (!SWIG_IsOK(ecode)) {
35635 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35636 }
35637 temp3 = static_cast< int >(val);
35638 arg3 = &temp3;
35639 res3 = SWIG_AddTmpMask(ecode);
35640 }
35641 {
35642 PyThreadState* __tstate = wxPyBeginAllowThreads();
35643 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 resultobj = SWIG_Py_Void();
35648 if (SWIG_IsTmpObj(res2)) {
35649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35650 } else {
35651 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35653 }
35654 if (SWIG_IsTmpObj(res3)) {
35655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35656 } else {
35657 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35659 }
35660 return resultobj;
35661 fail:
35662 return NULL;
35663 }
35664
35665
35666 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35667 PyObject *resultobj = 0;
35668 wxWindow *arg1 = (wxWindow *) 0 ;
35669 int *arg2 = (int *) 0 ;
35670 int *arg3 = (int *) 0 ;
35671 void *argp1 = 0 ;
35672 int res1 = 0 ;
35673 int temp2 ;
35674 int res2 = 0 ;
35675 int temp3 ;
35676 int res3 = 0 ;
35677 PyObject * obj0 = 0 ;
35678 PyObject * obj1 = 0 ;
35679 PyObject * obj2 = 0 ;
35680 char * kwnames[] = {
35681 (char *) "self",(char *) "x",(char *) "y", NULL
35682 };
35683
35684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35686 if (!SWIG_IsOK(res1)) {
35687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35688 }
35689 arg1 = reinterpret_cast< wxWindow * >(argp1);
35690 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35691 int val;
35692 int ecode = SWIG_AsVal_int(obj1, &val);
35693 if (!SWIG_IsOK(ecode)) {
35694 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35695 }
35696 temp2 = static_cast< int >(val);
35697 arg2 = &temp2;
35698 res2 = SWIG_AddTmpMask(ecode);
35699 }
35700 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35701 int val;
35702 int ecode = SWIG_AsVal_int(obj2, &val);
35703 if (!SWIG_IsOK(ecode)) {
35704 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35705 }
35706 temp3 = static_cast< int >(val);
35707 arg3 = &temp3;
35708 res3 = SWIG_AddTmpMask(ecode);
35709 }
35710 {
35711 PyThreadState* __tstate = wxPyBeginAllowThreads();
35712 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35713 wxPyEndAllowThreads(__tstate);
35714 if (PyErr_Occurred()) SWIG_fail;
35715 }
35716 resultobj = SWIG_Py_Void();
35717 if (SWIG_IsTmpObj(res2)) {
35718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35719 } else {
35720 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35722 }
35723 if (SWIG_IsTmpObj(res3)) {
35724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35725 } else {
35726 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35728 }
35729 return resultobj;
35730 fail:
35731 return NULL;
35732 }
35733
35734
35735 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35736 PyObject *resultobj = 0;
35737 wxWindow *arg1 = (wxWindow *) 0 ;
35738 wxPoint *arg2 = 0 ;
35739 wxPoint result;
35740 void *argp1 = 0 ;
35741 int res1 = 0 ;
35742 wxPoint temp2 ;
35743 PyObject * obj0 = 0 ;
35744 PyObject * obj1 = 0 ;
35745 char * kwnames[] = {
35746 (char *) "self",(char *) "pt", NULL
35747 };
35748
35749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35751 if (!SWIG_IsOK(res1)) {
35752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35753 }
35754 arg1 = reinterpret_cast< wxWindow * >(argp1);
35755 {
35756 arg2 = &temp2;
35757 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35758 }
35759 {
35760 PyThreadState* __tstate = wxPyBeginAllowThreads();
35761 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35762 wxPyEndAllowThreads(__tstate);
35763 if (PyErr_Occurred()) SWIG_fail;
35764 }
35765 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35766 return resultobj;
35767 fail:
35768 return NULL;
35769 }
35770
35771
35772 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35773 PyObject *resultobj = 0;
35774 wxWindow *arg1 = (wxWindow *) 0 ;
35775 wxPoint *arg2 = 0 ;
35776 wxPoint result;
35777 void *argp1 = 0 ;
35778 int res1 = 0 ;
35779 wxPoint temp2 ;
35780 PyObject * obj0 = 0 ;
35781 PyObject * obj1 = 0 ;
35782 char * kwnames[] = {
35783 (char *) "self",(char *) "pt", NULL
35784 };
35785
35786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35788 if (!SWIG_IsOK(res1)) {
35789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35790 }
35791 arg1 = reinterpret_cast< wxWindow * >(argp1);
35792 {
35793 arg2 = &temp2;
35794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35795 }
35796 {
35797 PyThreadState* __tstate = wxPyBeginAllowThreads();
35798 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35799 wxPyEndAllowThreads(__tstate);
35800 if (PyErr_Occurred()) SWIG_fail;
35801 }
35802 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35803 return resultobj;
35804 fail:
35805 return NULL;
35806 }
35807
35808
35809 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35810 PyObject *resultobj = 0;
35811 wxWindow *arg1 = (wxWindow *) 0 ;
35812 int arg2 ;
35813 int arg3 ;
35814 wxHitTest result;
35815 void *argp1 = 0 ;
35816 int res1 = 0 ;
35817 int val2 ;
35818 int ecode2 = 0 ;
35819 int val3 ;
35820 int ecode3 = 0 ;
35821 PyObject * obj0 = 0 ;
35822 PyObject * obj1 = 0 ;
35823 PyObject * obj2 = 0 ;
35824 char * kwnames[] = {
35825 (char *) "self",(char *) "x",(char *) "y", NULL
35826 };
35827
35828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35830 if (!SWIG_IsOK(res1)) {
35831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35832 }
35833 arg1 = reinterpret_cast< wxWindow * >(argp1);
35834 ecode2 = SWIG_AsVal_int(obj1, &val2);
35835 if (!SWIG_IsOK(ecode2)) {
35836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35837 }
35838 arg2 = static_cast< int >(val2);
35839 ecode3 = SWIG_AsVal_int(obj2, &val3);
35840 if (!SWIG_IsOK(ecode3)) {
35841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35842 }
35843 arg3 = static_cast< int >(val3);
35844 {
35845 PyThreadState* __tstate = wxPyBeginAllowThreads();
35846 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35847 wxPyEndAllowThreads(__tstate);
35848 if (PyErr_Occurred()) SWIG_fail;
35849 }
35850 resultobj = SWIG_From_int(static_cast< int >(result));
35851 return resultobj;
35852 fail:
35853 return NULL;
35854 }
35855
35856
35857 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35858 PyObject *resultobj = 0;
35859 wxWindow *arg1 = (wxWindow *) 0 ;
35860 wxPoint *arg2 = 0 ;
35861 wxHitTest result;
35862 void *argp1 = 0 ;
35863 int res1 = 0 ;
35864 wxPoint temp2 ;
35865 PyObject * obj0 = 0 ;
35866 PyObject * obj1 = 0 ;
35867 char * kwnames[] = {
35868 (char *) "self",(char *) "pt", NULL
35869 };
35870
35871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35873 if (!SWIG_IsOK(res1)) {
35874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35875 }
35876 arg1 = reinterpret_cast< wxWindow * >(argp1);
35877 {
35878 arg2 = &temp2;
35879 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35880 }
35881 {
35882 PyThreadState* __tstate = wxPyBeginAllowThreads();
35883 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35884 wxPyEndAllowThreads(__tstate);
35885 if (PyErr_Occurred()) SWIG_fail;
35886 }
35887 resultobj = SWIG_From_int(static_cast< int >(result));
35888 return resultobj;
35889 fail:
35890 return NULL;
35891 }
35892
35893
35894 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35895 PyObject *resultobj = 0;
35896 wxWindow *arg1 = (wxWindow *) 0 ;
35897 long arg2 ;
35898 wxBorder result;
35899 void *argp1 = 0 ;
35900 int res1 = 0 ;
35901 long val2 ;
35902 int ecode2 = 0 ;
35903
35904 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35906 if (!SWIG_IsOK(res1)) {
35907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35908 }
35909 arg1 = reinterpret_cast< wxWindow * >(argp1);
35910 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35911 if (!SWIG_IsOK(ecode2)) {
35912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35913 }
35914 arg2 = static_cast< long >(val2);
35915 {
35916 PyThreadState* __tstate = wxPyBeginAllowThreads();
35917 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35918 wxPyEndAllowThreads(__tstate);
35919 if (PyErr_Occurred()) SWIG_fail;
35920 }
35921 resultobj = SWIG_From_int(static_cast< int >(result));
35922 return resultobj;
35923 fail:
35924 return NULL;
35925 }
35926
35927
35928 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35929 PyObject *resultobj = 0;
35930 wxWindow *arg1 = (wxWindow *) 0 ;
35931 wxBorder result;
35932 void *argp1 = 0 ;
35933 int res1 = 0 ;
35934
35935 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35937 if (!SWIG_IsOK(res1)) {
35938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35939 }
35940 arg1 = reinterpret_cast< wxWindow * >(argp1);
35941 {
35942 PyThreadState* __tstate = wxPyBeginAllowThreads();
35943 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35944 wxPyEndAllowThreads(__tstate);
35945 if (PyErr_Occurred()) SWIG_fail;
35946 }
35947 resultobj = SWIG_From_int(static_cast< int >(result));
35948 return resultobj;
35949 fail:
35950 return NULL;
35951 }
35952
35953
35954 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35955 int argc;
35956 PyObject *argv[3];
35957
35958 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35959 --argc;
35960 if (argc == 1) {
35961 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35962 }
35963 if (argc == 2) {
35964 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35965 }
35966
35967 fail:
35968 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35969 return NULL;
35970 }
35971
35972
35973 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35974 PyObject *resultobj = 0;
35975 wxWindow *arg1 = (wxWindow *) 0 ;
35976 long arg2 = (long) wxUPDATE_UI_NONE ;
35977 void *argp1 = 0 ;
35978 int res1 = 0 ;
35979 long val2 ;
35980 int ecode2 = 0 ;
35981 PyObject * obj0 = 0 ;
35982 PyObject * obj1 = 0 ;
35983 char * kwnames[] = {
35984 (char *) "self",(char *) "flags", NULL
35985 };
35986
35987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35989 if (!SWIG_IsOK(res1)) {
35990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35991 }
35992 arg1 = reinterpret_cast< wxWindow * >(argp1);
35993 if (obj1) {
35994 ecode2 = SWIG_AsVal_long(obj1, &val2);
35995 if (!SWIG_IsOK(ecode2)) {
35996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35997 }
35998 arg2 = static_cast< long >(val2);
35999 }
36000 {
36001 PyThreadState* __tstate = wxPyBeginAllowThreads();
36002 (arg1)->UpdateWindowUI(arg2);
36003 wxPyEndAllowThreads(__tstate);
36004 if (PyErr_Occurred()) SWIG_fail;
36005 }
36006 resultobj = SWIG_Py_Void();
36007 return resultobj;
36008 fail:
36009 return NULL;
36010 }
36011
36012
36013 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36014 PyObject *resultobj = 0;
36015 wxWindow *arg1 = (wxWindow *) 0 ;
36016 wxMenu *arg2 = (wxMenu *) 0 ;
36017 int arg3 = (int) -1 ;
36018 int arg4 = (int) -1 ;
36019 bool result;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 void *argp2 = 0 ;
36023 int res2 = 0 ;
36024 int val3 ;
36025 int ecode3 = 0 ;
36026 int val4 ;
36027 int ecode4 = 0 ;
36028 PyObject * obj0 = 0 ;
36029 PyObject * obj1 = 0 ;
36030 PyObject * obj2 = 0 ;
36031 PyObject * obj3 = 0 ;
36032 char * kwnames[] = {
36033 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36034 };
36035
36036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36038 if (!SWIG_IsOK(res1)) {
36039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36040 }
36041 arg1 = reinterpret_cast< wxWindow * >(argp1);
36042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36043 if (!SWIG_IsOK(res2)) {
36044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36045 }
36046 arg2 = reinterpret_cast< wxMenu * >(argp2);
36047 if (obj2) {
36048 ecode3 = SWIG_AsVal_int(obj2, &val3);
36049 if (!SWIG_IsOK(ecode3)) {
36050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36051 }
36052 arg3 = static_cast< int >(val3);
36053 }
36054 if (obj3) {
36055 ecode4 = SWIG_AsVal_int(obj3, &val4);
36056 if (!SWIG_IsOK(ecode4)) {
36057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36058 }
36059 arg4 = static_cast< int >(val4);
36060 }
36061 {
36062 PyThreadState* __tstate = wxPyBeginAllowThreads();
36063 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36064 wxPyEndAllowThreads(__tstate);
36065 if (PyErr_Occurred()) SWIG_fail;
36066 }
36067 {
36068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36069 }
36070 return resultobj;
36071 fail:
36072 return NULL;
36073 }
36074
36075
36076 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36077 PyObject *resultobj = 0;
36078 wxWindow *arg1 = (wxWindow *) 0 ;
36079 wxMenu *arg2 = (wxMenu *) 0 ;
36080 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36081 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36082 bool result;
36083 void *argp1 = 0 ;
36084 int res1 = 0 ;
36085 void *argp2 = 0 ;
36086 int res2 = 0 ;
36087 wxPoint temp3 ;
36088 PyObject * obj0 = 0 ;
36089 PyObject * obj1 = 0 ;
36090 PyObject * obj2 = 0 ;
36091 char * kwnames[] = {
36092 (char *) "self",(char *) "menu",(char *) "pos", NULL
36093 };
36094
36095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36097 if (!SWIG_IsOK(res1)) {
36098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36099 }
36100 arg1 = reinterpret_cast< wxWindow * >(argp1);
36101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36102 if (!SWIG_IsOK(res2)) {
36103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36104 }
36105 arg2 = reinterpret_cast< wxMenu * >(argp2);
36106 if (obj2) {
36107 {
36108 arg3 = &temp3;
36109 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36110 }
36111 }
36112 {
36113 PyThreadState* __tstate = wxPyBeginAllowThreads();
36114 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36115 wxPyEndAllowThreads(__tstate);
36116 if (PyErr_Occurred()) SWIG_fail;
36117 }
36118 {
36119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36120 }
36121 return resultobj;
36122 fail:
36123 return NULL;
36124 }
36125
36126
36127 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36128 PyObject *resultobj = 0;
36129 wxWindow *arg1 = (wxWindow *) 0 ;
36130 long result;
36131 void *argp1 = 0 ;
36132 int res1 = 0 ;
36133 PyObject *swig_obj[1] ;
36134
36135 if (!args) SWIG_fail;
36136 swig_obj[0] = args;
36137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36138 if (!SWIG_IsOK(res1)) {
36139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36140 }
36141 arg1 = reinterpret_cast< wxWindow * >(argp1);
36142 {
36143 PyThreadState* __tstate = wxPyBeginAllowThreads();
36144 result = (long)wxWindow_GetHandle(arg1);
36145 wxPyEndAllowThreads(__tstate);
36146 if (PyErr_Occurred()) SWIG_fail;
36147 }
36148 resultobj = SWIG_From_long(static_cast< long >(result));
36149 return resultobj;
36150 fail:
36151 return NULL;
36152 }
36153
36154
36155 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36156 PyObject *resultobj = 0;
36157 wxWindow *arg1 = (wxWindow *) 0 ;
36158 long arg2 ;
36159 void *argp1 = 0 ;
36160 int res1 = 0 ;
36161 long val2 ;
36162 int ecode2 = 0 ;
36163 PyObject * obj0 = 0 ;
36164 PyObject * obj1 = 0 ;
36165 char * kwnames[] = {
36166 (char *) "self",(char *) "handle", NULL
36167 };
36168
36169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36171 if (!SWIG_IsOK(res1)) {
36172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36173 }
36174 arg1 = reinterpret_cast< wxWindow * >(argp1);
36175 ecode2 = SWIG_AsVal_long(obj1, &val2);
36176 if (!SWIG_IsOK(ecode2)) {
36177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36178 }
36179 arg2 = static_cast< long >(val2);
36180 {
36181 PyThreadState* __tstate = wxPyBeginAllowThreads();
36182 wxWindow_AssociateHandle(arg1,arg2);
36183 wxPyEndAllowThreads(__tstate);
36184 if (PyErr_Occurred()) SWIG_fail;
36185 }
36186 resultobj = SWIG_Py_Void();
36187 return resultobj;
36188 fail:
36189 return NULL;
36190 }
36191
36192
36193 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36194 PyObject *resultobj = 0;
36195 wxWindow *arg1 = (wxWindow *) 0 ;
36196 void *argp1 = 0 ;
36197 int res1 = 0 ;
36198 PyObject *swig_obj[1] ;
36199
36200 if (!args) SWIG_fail;
36201 swig_obj[0] = args;
36202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36203 if (!SWIG_IsOK(res1)) {
36204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36205 }
36206 arg1 = reinterpret_cast< wxWindow * >(argp1);
36207 {
36208 PyThreadState* __tstate = wxPyBeginAllowThreads();
36209 (arg1)->DissociateHandle();
36210 wxPyEndAllowThreads(__tstate);
36211 if (PyErr_Occurred()) SWIG_fail;
36212 }
36213 resultobj = SWIG_Py_Void();
36214 return resultobj;
36215 fail:
36216 return NULL;
36217 }
36218
36219
36220 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36221 PyObject *resultobj = 0;
36222 wxWindow *arg1 = (wxWindow *) 0 ;
36223 int arg2 ;
36224 bool result;
36225 void *argp1 = 0 ;
36226 int res1 = 0 ;
36227 int val2 ;
36228 int ecode2 = 0 ;
36229 PyObject * obj0 = 0 ;
36230 PyObject * obj1 = 0 ;
36231 char * kwnames[] = {
36232 (char *) "self",(char *) "orient", NULL
36233 };
36234
36235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36237 if (!SWIG_IsOK(res1)) {
36238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36239 }
36240 arg1 = reinterpret_cast< wxWindow * >(argp1);
36241 ecode2 = SWIG_AsVal_int(obj1, &val2);
36242 if (!SWIG_IsOK(ecode2)) {
36243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36244 }
36245 arg2 = static_cast< int >(val2);
36246 {
36247 PyThreadState* __tstate = wxPyBeginAllowThreads();
36248 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36249 wxPyEndAllowThreads(__tstate);
36250 if (PyErr_Occurred()) SWIG_fail;
36251 }
36252 {
36253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36254 }
36255 return resultobj;
36256 fail:
36257 return NULL;
36258 }
36259
36260
36261 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36262 PyObject *resultobj = 0;
36263 wxWindow *arg1 = (wxWindow *) 0 ;
36264 int arg2 ;
36265 int arg3 ;
36266 int arg4 ;
36267 int arg5 ;
36268 bool arg6 = (bool) true ;
36269 void *argp1 = 0 ;
36270 int res1 = 0 ;
36271 int val2 ;
36272 int ecode2 = 0 ;
36273 int val3 ;
36274 int ecode3 = 0 ;
36275 int val4 ;
36276 int ecode4 = 0 ;
36277 int val5 ;
36278 int ecode5 = 0 ;
36279 bool val6 ;
36280 int ecode6 = 0 ;
36281 PyObject * obj0 = 0 ;
36282 PyObject * obj1 = 0 ;
36283 PyObject * obj2 = 0 ;
36284 PyObject * obj3 = 0 ;
36285 PyObject * obj4 = 0 ;
36286 PyObject * obj5 = 0 ;
36287 char * kwnames[] = {
36288 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36289 };
36290
36291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36293 if (!SWIG_IsOK(res1)) {
36294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36295 }
36296 arg1 = reinterpret_cast< wxWindow * >(argp1);
36297 ecode2 = SWIG_AsVal_int(obj1, &val2);
36298 if (!SWIG_IsOK(ecode2)) {
36299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36300 }
36301 arg2 = static_cast< int >(val2);
36302 ecode3 = SWIG_AsVal_int(obj2, &val3);
36303 if (!SWIG_IsOK(ecode3)) {
36304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36305 }
36306 arg3 = static_cast< int >(val3);
36307 ecode4 = SWIG_AsVal_int(obj3, &val4);
36308 if (!SWIG_IsOK(ecode4)) {
36309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36310 }
36311 arg4 = static_cast< int >(val4);
36312 ecode5 = SWIG_AsVal_int(obj4, &val5);
36313 if (!SWIG_IsOK(ecode5)) {
36314 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36315 }
36316 arg5 = static_cast< int >(val5);
36317 if (obj5) {
36318 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36319 if (!SWIG_IsOK(ecode6)) {
36320 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36321 }
36322 arg6 = static_cast< bool >(val6);
36323 }
36324 {
36325 PyThreadState* __tstate = wxPyBeginAllowThreads();
36326 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36327 wxPyEndAllowThreads(__tstate);
36328 if (PyErr_Occurred()) SWIG_fail;
36329 }
36330 resultobj = SWIG_Py_Void();
36331 return resultobj;
36332 fail:
36333 return NULL;
36334 }
36335
36336
36337 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36338 PyObject *resultobj = 0;
36339 wxWindow *arg1 = (wxWindow *) 0 ;
36340 int arg2 ;
36341 int arg3 ;
36342 bool arg4 = (bool) true ;
36343 void *argp1 = 0 ;
36344 int res1 = 0 ;
36345 int val2 ;
36346 int ecode2 = 0 ;
36347 int val3 ;
36348 int ecode3 = 0 ;
36349 bool val4 ;
36350 int ecode4 = 0 ;
36351 PyObject * obj0 = 0 ;
36352 PyObject * obj1 = 0 ;
36353 PyObject * obj2 = 0 ;
36354 PyObject * obj3 = 0 ;
36355 char * kwnames[] = {
36356 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36357 };
36358
36359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36361 if (!SWIG_IsOK(res1)) {
36362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36363 }
36364 arg1 = reinterpret_cast< wxWindow * >(argp1);
36365 ecode2 = SWIG_AsVal_int(obj1, &val2);
36366 if (!SWIG_IsOK(ecode2)) {
36367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36368 }
36369 arg2 = static_cast< int >(val2);
36370 ecode3 = SWIG_AsVal_int(obj2, &val3);
36371 if (!SWIG_IsOK(ecode3)) {
36372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36373 }
36374 arg3 = static_cast< int >(val3);
36375 if (obj3) {
36376 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36377 if (!SWIG_IsOK(ecode4)) {
36378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36379 }
36380 arg4 = static_cast< bool >(val4);
36381 }
36382 {
36383 PyThreadState* __tstate = wxPyBeginAllowThreads();
36384 (arg1)->SetScrollPos(arg2,arg3,arg4);
36385 wxPyEndAllowThreads(__tstate);
36386 if (PyErr_Occurred()) SWIG_fail;
36387 }
36388 resultobj = SWIG_Py_Void();
36389 return resultobj;
36390 fail:
36391 return NULL;
36392 }
36393
36394
36395 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36396 PyObject *resultobj = 0;
36397 wxWindow *arg1 = (wxWindow *) 0 ;
36398 int arg2 ;
36399 int result;
36400 void *argp1 = 0 ;
36401 int res1 = 0 ;
36402 int val2 ;
36403 int ecode2 = 0 ;
36404 PyObject * obj0 = 0 ;
36405 PyObject * obj1 = 0 ;
36406 char * kwnames[] = {
36407 (char *) "self",(char *) "orientation", NULL
36408 };
36409
36410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36412 if (!SWIG_IsOK(res1)) {
36413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36414 }
36415 arg1 = reinterpret_cast< wxWindow * >(argp1);
36416 ecode2 = SWIG_AsVal_int(obj1, &val2);
36417 if (!SWIG_IsOK(ecode2)) {
36418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36419 }
36420 arg2 = static_cast< int >(val2);
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36424 wxPyEndAllowThreads(__tstate);
36425 if (PyErr_Occurred()) SWIG_fail;
36426 }
36427 resultobj = SWIG_From_int(static_cast< int >(result));
36428 return resultobj;
36429 fail:
36430 return NULL;
36431 }
36432
36433
36434 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36435 PyObject *resultobj = 0;
36436 wxWindow *arg1 = (wxWindow *) 0 ;
36437 int arg2 ;
36438 int result;
36439 void *argp1 = 0 ;
36440 int res1 = 0 ;
36441 int val2 ;
36442 int ecode2 = 0 ;
36443 PyObject * obj0 = 0 ;
36444 PyObject * obj1 = 0 ;
36445 char * kwnames[] = {
36446 (char *) "self",(char *) "orientation", NULL
36447 };
36448
36449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36451 if (!SWIG_IsOK(res1)) {
36452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36453 }
36454 arg1 = reinterpret_cast< wxWindow * >(argp1);
36455 ecode2 = SWIG_AsVal_int(obj1, &val2);
36456 if (!SWIG_IsOK(ecode2)) {
36457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36458 }
36459 arg2 = static_cast< int >(val2);
36460 {
36461 PyThreadState* __tstate = wxPyBeginAllowThreads();
36462 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36463 wxPyEndAllowThreads(__tstate);
36464 if (PyErr_Occurred()) SWIG_fail;
36465 }
36466 resultobj = SWIG_From_int(static_cast< int >(result));
36467 return resultobj;
36468 fail:
36469 return NULL;
36470 }
36471
36472
36473 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36474 PyObject *resultobj = 0;
36475 wxWindow *arg1 = (wxWindow *) 0 ;
36476 int arg2 ;
36477 int result;
36478 void *argp1 = 0 ;
36479 int res1 = 0 ;
36480 int val2 ;
36481 int ecode2 = 0 ;
36482 PyObject * obj0 = 0 ;
36483 PyObject * obj1 = 0 ;
36484 char * kwnames[] = {
36485 (char *) "self",(char *) "orientation", NULL
36486 };
36487
36488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36490 if (!SWIG_IsOK(res1)) {
36491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36492 }
36493 arg1 = reinterpret_cast< wxWindow * >(argp1);
36494 ecode2 = SWIG_AsVal_int(obj1, &val2);
36495 if (!SWIG_IsOK(ecode2)) {
36496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36497 }
36498 arg2 = static_cast< int >(val2);
36499 {
36500 PyThreadState* __tstate = wxPyBeginAllowThreads();
36501 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36502 wxPyEndAllowThreads(__tstate);
36503 if (PyErr_Occurred()) SWIG_fail;
36504 }
36505 resultobj = SWIG_From_int(static_cast< int >(result));
36506 return resultobj;
36507 fail:
36508 return NULL;
36509 }
36510
36511
36512 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36513 PyObject *resultobj = 0;
36514 wxWindow *arg1 = (wxWindow *) 0 ;
36515 int arg2 ;
36516 int arg3 ;
36517 wxRect *arg4 = (wxRect *) NULL ;
36518 void *argp1 = 0 ;
36519 int res1 = 0 ;
36520 int val2 ;
36521 int ecode2 = 0 ;
36522 int val3 ;
36523 int ecode3 = 0 ;
36524 void *argp4 = 0 ;
36525 int res4 = 0 ;
36526 PyObject * obj0 = 0 ;
36527 PyObject * obj1 = 0 ;
36528 PyObject * obj2 = 0 ;
36529 PyObject * obj3 = 0 ;
36530 char * kwnames[] = {
36531 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36532 };
36533
36534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36536 if (!SWIG_IsOK(res1)) {
36537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36538 }
36539 arg1 = reinterpret_cast< wxWindow * >(argp1);
36540 ecode2 = SWIG_AsVal_int(obj1, &val2);
36541 if (!SWIG_IsOK(ecode2)) {
36542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36543 }
36544 arg2 = static_cast< int >(val2);
36545 ecode3 = SWIG_AsVal_int(obj2, &val3);
36546 if (!SWIG_IsOK(ecode3)) {
36547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36548 }
36549 arg3 = static_cast< int >(val3);
36550 if (obj3) {
36551 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36552 if (!SWIG_IsOK(res4)) {
36553 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36554 }
36555 arg4 = reinterpret_cast< wxRect * >(argp4);
36556 }
36557 {
36558 PyThreadState* __tstate = wxPyBeginAllowThreads();
36559 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36560 wxPyEndAllowThreads(__tstate);
36561 if (PyErr_Occurred()) SWIG_fail;
36562 }
36563 resultobj = SWIG_Py_Void();
36564 return resultobj;
36565 fail:
36566 return NULL;
36567 }
36568
36569
36570 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36571 PyObject *resultobj = 0;
36572 wxWindow *arg1 = (wxWindow *) 0 ;
36573 int arg2 ;
36574 bool result;
36575 void *argp1 = 0 ;
36576 int res1 = 0 ;
36577 int val2 ;
36578 int ecode2 = 0 ;
36579 PyObject * obj0 = 0 ;
36580 PyObject * obj1 = 0 ;
36581 char * kwnames[] = {
36582 (char *) "self",(char *) "lines", NULL
36583 };
36584
36585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36587 if (!SWIG_IsOK(res1)) {
36588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36589 }
36590 arg1 = reinterpret_cast< wxWindow * >(argp1);
36591 ecode2 = SWIG_AsVal_int(obj1, &val2);
36592 if (!SWIG_IsOK(ecode2)) {
36593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36594 }
36595 arg2 = static_cast< int >(val2);
36596 {
36597 PyThreadState* __tstate = wxPyBeginAllowThreads();
36598 result = (bool)(arg1)->ScrollLines(arg2);
36599 wxPyEndAllowThreads(__tstate);
36600 if (PyErr_Occurred()) SWIG_fail;
36601 }
36602 {
36603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36604 }
36605 return resultobj;
36606 fail:
36607 return NULL;
36608 }
36609
36610
36611 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36612 PyObject *resultobj = 0;
36613 wxWindow *arg1 = (wxWindow *) 0 ;
36614 int arg2 ;
36615 bool result;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 int val2 ;
36619 int ecode2 = 0 ;
36620 PyObject * obj0 = 0 ;
36621 PyObject * obj1 = 0 ;
36622 char * kwnames[] = {
36623 (char *) "self",(char *) "pages", NULL
36624 };
36625
36626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36628 if (!SWIG_IsOK(res1)) {
36629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36630 }
36631 arg1 = reinterpret_cast< wxWindow * >(argp1);
36632 ecode2 = SWIG_AsVal_int(obj1, &val2);
36633 if (!SWIG_IsOK(ecode2)) {
36634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36635 }
36636 arg2 = static_cast< int >(val2);
36637 {
36638 PyThreadState* __tstate = wxPyBeginAllowThreads();
36639 result = (bool)(arg1)->ScrollPages(arg2);
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 {
36644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36645 }
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36653 PyObject *resultobj = 0;
36654 wxWindow *arg1 = (wxWindow *) 0 ;
36655 bool result;
36656 void *argp1 = 0 ;
36657 int res1 = 0 ;
36658 PyObject *swig_obj[1] ;
36659
36660 if (!args) SWIG_fail;
36661 swig_obj[0] = args;
36662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36663 if (!SWIG_IsOK(res1)) {
36664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36665 }
36666 arg1 = reinterpret_cast< wxWindow * >(argp1);
36667 {
36668 PyThreadState* __tstate = wxPyBeginAllowThreads();
36669 result = (bool)(arg1)->LineUp();
36670 wxPyEndAllowThreads(__tstate);
36671 if (PyErr_Occurred()) SWIG_fail;
36672 }
36673 {
36674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36675 }
36676 return resultobj;
36677 fail:
36678 return NULL;
36679 }
36680
36681
36682 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36683 PyObject *resultobj = 0;
36684 wxWindow *arg1 = (wxWindow *) 0 ;
36685 bool result;
36686 void *argp1 = 0 ;
36687 int res1 = 0 ;
36688 PyObject *swig_obj[1] ;
36689
36690 if (!args) SWIG_fail;
36691 swig_obj[0] = args;
36692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36693 if (!SWIG_IsOK(res1)) {
36694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36695 }
36696 arg1 = reinterpret_cast< wxWindow * >(argp1);
36697 {
36698 PyThreadState* __tstate = wxPyBeginAllowThreads();
36699 result = (bool)(arg1)->LineDown();
36700 wxPyEndAllowThreads(__tstate);
36701 if (PyErr_Occurred()) SWIG_fail;
36702 }
36703 {
36704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36705 }
36706 return resultobj;
36707 fail:
36708 return NULL;
36709 }
36710
36711
36712 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36713 PyObject *resultobj = 0;
36714 wxWindow *arg1 = (wxWindow *) 0 ;
36715 bool result;
36716 void *argp1 = 0 ;
36717 int res1 = 0 ;
36718 PyObject *swig_obj[1] ;
36719
36720 if (!args) SWIG_fail;
36721 swig_obj[0] = args;
36722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36725 }
36726 arg1 = reinterpret_cast< wxWindow * >(argp1);
36727 {
36728 PyThreadState* __tstate = wxPyBeginAllowThreads();
36729 result = (bool)(arg1)->PageUp();
36730 wxPyEndAllowThreads(__tstate);
36731 if (PyErr_Occurred()) SWIG_fail;
36732 }
36733 {
36734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36735 }
36736 return resultobj;
36737 fail:
36738 return NULL;
36739 }
36740
36741
36742 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36743 PyObject *resultobj = 0;
36744 wxWindow *arg1 = (wxWindow *) 0 ;
36745 bool result;
36746 void *argp1 = 0 ;
36747 int res1 = 0 ;
36748 PyObject *swig_obj[1] ;
36749
36750 if (!args) SWIG_fail;
36751 swig_obj[0] = args;
36752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36753 if (!SWIG_IsOK(res1)) {
36754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36755 }
36756 arg1 = reinterpret_cast< wxWindow * >(argp1);
36757 {
36758 PyThreadState* __tstate = wxPyBeginAllowThreads();
36759 result = (bool)(arg1)->PageDown();
36760 wxPyEndAllowThreads(__tstate);
36761 if (PyErr_Occurred()) SWIG_fail;
36762 }
36763 {
36764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36765 }
36766 return resultobj;
36767 fail:
36768 return NULL;
36769 }
36770
36771
36772 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36773 PyObject *resultobj = 0;
36774 wxWindow *arg1 = (wxWindow *) 0 ;
36775 wxString *arg2 = 0 ;
36776 void *argp1 = 0 ;
36777 int res1 = 0 ;
36778 bool temp2 = false ;
36779 PyObject * obj0 = 0 ;
36780 PyObject * obj1 = 0 ;
36781 char * kwnames[] = {
36782 (char *) "self",(char *) "text", NULL
36783 };
36784
36785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36787 if (!SWIG_IsOK(res1)) {
36788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36789 }
36790 arg1 = reinterpret_cast< wxWindow * >(argp1);
36791 {
36792 arg2 = wxString_in_helper(obj1);
36793 if (arg2 == NULL) SWIG_fail;
36794 temp2 = true;
36795 }
36796 {
36797 PyThreadState* __tstate = wxPyBeginAllowThreads();
36798 (arg1)->SetHelpText((wxString const &)*arg2);
36799 wxPyEndAllowThreads(__tstate);
36800 if (PyErr_Occurred()) SWIG_fail;
36801 }
36802 resultobj = SWIG_Py_Void();
36803 {
36804 if (temp2)
36805 delete arg2;
36806 }
36807 return resultobj;
36808 fail:
36809 {
36810 if (temp2)
36811 delete arg2;
36812 }
36813 return NULL;
36814 }
36815
36816
36817 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36818 PyObject *resultobj = 0;
36819 wxWindow *arg1 = (wxWindow *) 0 ;
36820 wxString *arg2 = 0 ;
36821 void *argp1 = 0 ;
36822 int res1 = 0 ;
36823 bool temp2 = false ;
36824 PyObject * obj0 = 0 ;
36825 PyObject * obj1 = 0 ;
36826 char * kwnames[] = {
36827 (char *) "self",(char *) "text", NULL
36828 };
36829
36830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36832 if (!SWIG_IsOK(res1)) {
36833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36834 }
36835 arg1 = reinterpret_cast< wxWindow * >(argp1);
36836 {
36837 arg2 = wxString_in_helper(obj1);
36838 if (arg2 == NULL) SWIG_fail;
36839 temp2 = true;
36840 }
36841 {
36842 PyThreadState* __tstate = wxPyBeginAllowThreads();
36843 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 resultobj = SWIG_Py_Void();
36848 {
36849 if (temp2)
36850 delete arg2;
36851 }
36852 return resultobj;
36853 fail:
36854 {
36855 if (temp2)
36856 delete arg2;
36857 }
36858 return NULL;
36859 }
36860
36861
36862 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36863 PyObject *resultobj = 0;
36864 wxWindow *arg1 = (wxWindow *) 0 ;
36865 wxString result;
36866 void *argp1 = 0 ;
36867 int res1 = 0 ;
36868 PyObject *swig_obj[1] ;
36869
36870 if (!args) SWIG_fail;
36871 swig_obj[0] = args;
36872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36873 if (!SWIG_IsOK(res1)) {
36874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36875 }
36876 arg1 = reinterpret_cast< wxWindow * >(argp1);
36877 {
36878 PyThreadState* __tstate = wxPyBeginAllowThreads();
36879 result = ((wxWindow const *)arg1)->GetHelpText();
36880 wxPyEndAllowThreads(__tstate);
36881 if (PyErr_Occurred()) SWIG_fail;
36882 }
36883 {
36884 #if wxUSE_UNICODE
36885 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36886 #else
36887 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36888 #endif
36889 }
36890 return resultobj;
36891 fail:
36892 return NULL;
36893 }
36894
36895
36896 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36897 PyObject *resultobj = 0;
36898 wxWindow *arg1 = (wxWindow *) 0 ;
36899 wxString *arg2 = 0 ;
36900 void *argp1 = 0 ;
36901 int res1 = 0 ;
36902 bool temp2 = false ;
36903 PyObject * obj0 = 0 ;
36904 PyObject * obj1 = 0 ;
36905 char * kwnames[] = {
36906 (char *) "self",(char *) "tip", NULL
36907 };
36908
36909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36911 if (!SWIG_IsOK(res1)) {
36912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36913 }
36914 arg1 = reinterpret_cast< wxWindow * >(argp1);
36915 {
36916 arg2 = wxString_in_helper(obj1);
36917 if (arg2 == NULL) SWIG_fail;
36918 temp2 = true;
36919 }
36920 {
36921 PyThreadState* __tstate = wxPyBeginAllowThreads();
36922 (arg1)->SetToolTip((wxString const &)*arg2);
36923 wxPyEndAllowThreads(__tstate);
36924 if (PyErr_Occurred()) SWIG_fail;
36925 }
36926 resultobj = SWIG_Py_Void();
36927 {
36928 if (temp2)
36929 delete arg2;
36930 }
36931 return resultobj;
36932 fail:
36933 {
36934 if (temp2)
36935 delete arg2;
36936 }
36937 return NULL;
36938 }
36939
36940
36941 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36942 PyObject *resultobj = 0;
36943 wxWindow *arg1 = (wxWindow *) 0 ;
36944 wxToolTip *arg2 = (wxToolTip *) 0 ;
36945 void *argp1 = 0 ;
36946 int res1 = 0 ;
36947 int res2 = 0 ;
36948 PyObject * obj0 = 0 ;
36949 PyObject * obj1 = 0 ;
36950 char * kwnames[] = {
36951 (char *) "self",(char *) "tip", NULL
36952 };
36953
36954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36956 if (!SWIG_IsOK(res1)) {
36957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36958 }
36959 arg1 = reinterpret_cast< wxWindow * >(argp1);
36960 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36961 if (!SWIG_IsOK(res2)) {
36962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36963 }
36964 {
36965 PyThreadState* __tstate = wxPyBeginAllowThreads();
36966 (arg1)->SetToolTip(arg2);
36967 wxPyEndAllowThreads(__tstate);
36968 if (PyErr_Occurred()) SWIG_fail;
36969 }
36970 resultobj = SWIG_Py_Void();
36971 return resultobj;
36972 fail:
36973 return NULL;
36974 }
36975
36976
36977 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36978 PyObject *resultobj = 0;
36979 wxWindow *arg1 = (wxWindow *) 0 ;
36980 wxToolTip *result = 0 ;
36981 void *argp1 = 0 ;
36982 int res1 = 0 ;
36983 PyObject *swig_obj[1] ;
36984
36985 if (!args) SWIG_fail;
36986 swig_obj[0] = args;
36987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36988 if (!SWIG_IsOK(res1)) {
36989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36990 }
36991 arg1 = reinterpret_cast< wxWindow * >(argp1);
36992 {
36993 PyThreadState* __tstate = wxPyBeginAllowThreads();
36994 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36995 wxPyEndAllowThreads(__tstate);
36996 if (PyErr_Occurred()) SWIG_fail;
36997 }
36998 {
36999 resultobj = wxPyMake_wxObject(result, (bool)0);
37000 }
37001 return resultobj;
37002 fail:
37003 return NULL;
37004 }
37005
37006
37007 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37008 PyObject *resultobj = 0;
37009 wxWindow *arg1 = (wxWindow *) 0 ;
37010 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37011 void *argp1 = 0 ;
37012 int res1 = 0 ;
37013 int res2 = 0 ;
37014 PyObject * obj0 = 0 ;
37015 PyObject * obj1 = 0 ;
37016 char * kwnames[] = {
37017 (char *) "self",(char *) "dropTarget", NULL
37018 };
37019
37020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37022 if (!SWIG_IsOK(res1)) {
37023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37024 }
37025 arg1 = reinterpret_cast< wxWindow * >(argp1);
37026 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37027 if (!SWIG_IsOK(res2)) {
37028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37029 }
37030 {
37031 PyThreadState* __tstate = wxPyBeginAllowThreads();
37032 (arg1)->SetDropTarget(arg2);
37033 wxPyEndAllowThreads(__tstate);
37034 if (PyErr_Occurred()) SWIG_fail;
37035 }
37036 resultobj = SWIG_Py_Void();
37037 return resultobj;
37038 fail:
37039 return NULL;
37040 }
37041
37042
37043 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37044 PyObject *resultobj = 0;
37045 wxWindow *arg1 = (wxWindow *) 0 ;
37046 wxPyDropTarget *result = 0 ;
37047 void *argp1 = 0 ;
37048 int res1 = 0 ;
37049 PyObject *swig_obj[1] ;
37050
37051 if (!args) SWIG_fail;
37052 swig_obj[0] = args;
37053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37054 if (!SWIG_IsOK(res1)) {
37055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37056 }
37057 arg1 = reinterpret_cast< wxWindow * >(argp1);
37058 {
37059 PyThreadState* __tstate = wxPyBeginAllowThreads();
37060 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37061 wxPyEndAllowThreads(__tstate);
37062 if (PyErr_Occurred()) SWIG_fail;
37063 }
37064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37065 return resultobj;
37066 fail:
37067 return NULL;
37068 }
37069
37070
37071 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37072 PyObject *resultobj = 0;
37073 wxWindow *arg1 = (wxWindow *) 0 ;
37074 bool arg2 ;
37075 void *argp1 = 0 ;
37076 int res1 = 0 ;
37077 bool val2 ;
37078 int ecode2 = 0 ;
37079 PyObject * obj0 = 0 ;
37080 PyObject * obj1 = 0 ;
37081 char * kwnames[] = {
37082 (char *) "self",(char *) "accept", NULL
37083 };
37084
37085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37087 if (!SWIG_IsOK(res1)) {
37088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37089 }
37090 arg1 = reinterpret_cast< wxWindow * >(argp1);
37091 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37092 if (!SWIG_IsOK(ecode2)) {
37093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37094 }
37095 arg2 = static_cast< bool >(val2);
37096 {
37097 PyThreadState* __tstate = wxPyBeginAllowThreads();
37098 wxWindow_DragAcceptFiles(arg1,arg2);
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 resultobj = SWIG_Py_Void();
37103 return resultobj;
37104 fail:
37105 return NULL;
37106 }
37107
37108
37109 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37110 PyObject *resultobj = 0;
37111 wxWindow *arg1 = (wxWindow *) 0 ;
37112 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37113 void *argp1 = 0 ;
37114 int res1 = 0 ;
37115 int res2 = 0 ;
37116 PyObject * obj0 = 0 ;
37117 PyObject * obj1 = 0 ;
37118 char * kwnames[] = {
37119 (char *) "self",(char *) "constraints", NULL
37120 };
37121
37122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37124 if (!SWIG_IsOK(res1)) {
37125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37126 }
37127 arg1 = reinterpret_cast< wxWindow * >(argp1);
37128 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37129 if (!SWIG_IsOK(res2)) {
37130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37131 }
37132 {
37133 PyThreadState* __tstate = wxPyBeginAllowThreads();
37134 (arg1)->SetConstraints(arg2);
37135 wxPyEndAllowThreads(__tstate);
37136 if (PyErr_Occurred()) SWIG_fail;
37137 }
37138 resultobj = SWIG_Py_Void();
37139 return resultobj;
37140 fail:
37141 return NULL;
37142 }
37143
37144
37145 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37146 PyObject *resultobj = 0;
37147 wxWindow *arg1 = (wxWindow *) 0 ;
37148 wxLayoutConstraints *result = 0 ;
37149 void *argp1 = 0 ;
37150 int res1 = 0 ;
37151 PyObject *swig_obj[1] ;
37152
37153 if (!args) SWIG_fail;
37154 swig_obj[0] = args;
37155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37156 if (!SWIG_IsOK(res1)) {
37157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37158 }
37159 arg1 = reinterpret_cast< wxWindow * >(argp1);
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37163 wxPyEndAllowThreads(__tstate);
37164 if (PyErr_Occurred()) SWIG_fail;
37165 }
37166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37167 return resultobj;
37168 fail:
37169 return NULL;
37170 }
37171
37172
37173 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37174 PyObject *resultobj = 0;
37175 wxWindow *arg1 = (wxWindow *) 0 ;
37176 bool arg2 ;
37177 void *argp1 = 0 ;
37178 int res1 = 0 ;
37179 bool val2 ;
37180 int ecode2 = 0 ;
37181 PyObject * obj0 = 0 ;
37182 PyObject * obj1 = 0 ;
37183 char * kwnames[] = {
37184 (char *) "self",(char *) "autoLayout", NULL
37185 };
37186
37187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37189 if (!SWIG_IsOK(res1)) {
37190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37191 }
37192 arg1 = reinterpret_cast< wxWindow * >(argp1);
37193 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37194 if (!SWIG_IsOK(ecode2)) {
37195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37196 }
37197 arg2 = static_cast< bool >(val2);
37198 {
37199 PyThreadState* __tstate = wxPyBeginAllowThreads();
37200 (arg1)->SetAutoLayout(arg2);
37201 wxPyEndAllowThreads(__tstate);
37202 if (PyErr_Occurred()) SWIG_fail;
37203 }
37204 resultobj = SWIG_Py_Void();
37205 return resultobj;
37206 fail:
37207 return NULL;
37208 }
37209
37210
37211 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37212 PyObject *resultobj = 0;
37213 wxWindow *arg1 = (wxWindow *) 0 ;
37214 bool result;
37215 void *argp1 = 0 ;
37216 int res1 = 0 ;
37217 PyObject *swig_obj[1] ;
37218
37219 if (!args) SWIG_fail;
37220 swig_obj[0] = args;
37221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37222 if (!SWIG_IsOK(res1)) {
37223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37224 }
37225 arg1 = reinterpret_cast< wxWindow * >(argp1);
37226 {
37227 PyThreadState* __tstate = wxPyBeginAllowThreads();
37228 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37229 wxPyEndAllowThreads(__tstate);
37230 if (PyErr_Occurred()) SWIG_fail;
37231 }
37232 {
37233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37234 }
37235 return resultobj;
37236 fail:
37237 return NULL;
37238 }
37239
37240
37241 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37242 PyObject *resultobj = 0;
37243 wxWindow *arg1 = (wxWindow *) 0 ;
37244 bool result;
37245 void *argp1 = 0 ;
37246 int res1 = 0 ;
37247 PyObject *swig_obj[1] ;
37248
37249 if (!args) SWIG_fail;
37250 swig_obj[0] = args;
37251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37252 if (!SWIG_IsOK(res1)) {
37253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37254 }
37255 arg1 = reinterpret_cast< wxWindow * >(argp1);
37256 {
37257 PyThreadState* __tstate = wxPyBeginAllowThreads();
37258 result = (bool)(arg1)->Layout();
37259 wxPyEndAllowThreads(__tstate);
37260 if (PyErr_Occurred()) SWIG_fail;
37261 }
37262 {
37263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37264 }
37265 return resultobj;
37266 fail:
37267 return NULL;
37268 }
37269
37270
37271 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37272 PyObject *resultobj = 0;
37273 wxWindow *arg1 = (wxWindow *) 0 ;
37274 wxSizer *arg2 = (wxSizer *) 0 ;
37275 bool arg3 = (bool) true ;
37276 void *argp1 = 0 ;
37277 int res1 = 0 ;
37278 int res2 = 0 ;
37279 bool val3 ;
37280 int ecode3 = 0 ;
37281 PyObject * obj0 = 0 ;
37282 PyObject * obj1 = 0 ;
37283 PyObject * obj2 = 0 ;
37284 char * kwnames[] = {
37285 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37286 };
37287
37288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37290 if (!SWIG_IsOK(res1)) {
37291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37292 }
37293 arg1 = reinterpret_cast< wxWindow * >(argp1);
37294 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37295 if (!SWIG_IsOK(res2)) {
37296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37297 }
37298 if (obj2) {
37299 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37300 if (!SWIG_IsOK(ecode3)) {
37301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37302 }
37303 arg3 = static_cast< bool >(val3);
37304 }
37305 {
37306 PyThreadState* __tstate = wxPyBeginAllowThreads();
37307 (arg1)->SetSizer(arg2,arg3);
37308 wxPyEndAllowThreads(__tstate);
37309 if (PyErr_Occurred()) SWIG_fail;
37310 }
37311 resultobj = SWIG_Py_Void();
37312 return resultobj;
37313 fail:
37314 return NULL;
37315 }
37316
37317
37318 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37319 PyObject *resultobj = 0;
37320 wxWindow *arg1 = (wxWindow *) 0 ;
37321 wxSizer *arg2 = (wxSizer *) 0 ;
37322 bool arg3 = (bool) true ;
37323 void *argp1 = 0 ;
37324 int res1 = 0 ;
37325 int res2 = 0 ;
37326 bool val3 ;
37327 int ecode3 = 0 ;
37328 PyObject * obj0 = 0 ;
37329 PyObject * obj1 = 0 ;
37330 PyObject * obj2 = 0 ;
37331 char * kwnames[] = {
37332 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37333 };
37334
37335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37337 if (!SWIG_IsOK(res1)) {
37338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37339 }
37340 arg1 = reinterpret_cast< wxWindow * >(argp1);
37341 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37342 if (!SWIG_IsOK(res2)) {
37343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37344 }
37345 if (obj2) {
37346 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37347 if (!SWIG_IsOK(ecode3)) {
37348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37349 }
37350 arg3 = static_cast< bool >(val3);
37351 }
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 (arg1)->SetSizerAndFit(arg2,arg3);
37355 wxPyEndAllowThreads(__tstate);
37356 if (PyErr_Occurred()) SWIG_fail;
37357 }
37358 resultobj = SWIG_Py_Void();
37359 return resultobj;
37360 fail:
37361 return NULL;
37362 }
37363
37364
37365 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37366 PyObject *resultobj = 0;
37367 wxWindow *arg1 = (wxWindow *) 0 ;
37368 wxSizer *result = 0 ;
37369 void *argp1 = 0 ;
37370 int res1 = 0 ;
37371 PyObject *swig_obj[1] ;
37372
37373 if (!args) SWIG_fail;
37374 swig_obj[0] = args;
37375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37376 if (!SWIG_IsOK(res1)) {
37377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37378 }
37379 arg1 = reinterpret_cast< wxWindow * >(argp1);
37380 {
37381 PyThreadState* __tstate = wxPyBeginAllowThreads();
37382 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37383 wxPyEndAllowThreads(__tstate);
37384 if (PyErr_Occurred()) SWIG_fail;
37385 }
37386 {
37387 resultobj = wxPyMake_wxObject(result, (bool)0);
37388 }
37389 return resultobj;
37390 fail:
37391 return NULL;
37392 }
37393
37394
37395 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37396 PyObject *resultobj = 0;
37397 wxWindow *arg1 = (wxWindow *) 0 ;
37398 wxSizer *arg2 = (wxSizer *) 0 ;
37399 void *argp1 = 0 ;
37400 int res1 = 0 ;
37401 void *argp2 = 0 ;
37402 int res2 = 0 ;
37403 PyObject * obj0 = 0 ;
37404 PyObject * obj1 = 0 ;
37405 char * kwnames[] = {
37406 (char *) "self",(char *) "sizer", NULL
37407 };
37408
37409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37411 if (!SWIG_IsOK(res1)) {
37412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37413 }
37414 arg1 = reinterpret_cast< wxWindow * >(argp1);
37415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37416 if (!SWIG_IsOK(res2)) {
37417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37418 }
37419 arg2 = reinterpret_cast< wxSizer * >(argp2);
37420 {
37421 PyThreadState* __tstate = wxPyBeginAllowThreads();
37422 (arg1)->SetContainingSizer(arg2);
37423 wxPyEndAllowThreads(__tstate);
37424 if (PyErr_Occurred()) SWIG_fail;
37425 }
37426 resultobj = SWIG_Py_Void();
37427 return resultobj;
37428 fail:
37429 return NULL;
37430 }
37431
37432
37433 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37434 PyObject *resultobj = 0;
37435 wxWindow *arg1 = (wxWindow *) 0 ;
37436 wxSizer *result = 0 ;
37437 void *argp1 = 0 ;
37438 int res1 = 0 ;
37439 PyObject *swig_obj[1] ;
37440
37441 if (!args) SWIG_fail;
37442 swig_obj[0] = args;
37443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37444 if (!SWIG_IsOK(res1)) {
37445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37446 }
37447 arg1 = reinterpret_cast< wxWindow * >(argp1);
37448 {
37449 PyThreadState* __tstate = wxPyBeginAllowThreads();
37450 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37451 wxPyEndAllowThreads(__tstate);
37452 if (PyErr_Occurred()) SWIG_fail;
37453 }
37454 {
37455 resultobj = wxPyMake_wxObject(result, (bool)0);
37456 }
37457 return resultobj;
37458 fail:
37459 return NULL;
37460 }
37461
37462
37463 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37464 PyObject *resultobj = 0;
37465 wxWindow *arg1 = (wxWindow *) 0 ;
37466 void *argp1 = 0 ;
37467 int res1 = 0 ;
37468 PyObject *swig_obj[1] ;
37469
37470 if (!args) SWIG_fail;
37471 swig_obj[0] = args;
37472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37473 if (!SWIG_IsOK(res1)) {
37474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37475 }
37476 arg1 = reinterpret_cast< wxWindow * >(argp1);
37477 {
37478 PyThreadState* __tstate = wxPyBeginAllowThreads();
37479 (arg1)->InheritAttributes();
37480 wxPyEndAllowThreads(__tstate);
37481 if (PyErr_Occurred()) SWIG_fail;
37482 }
37483 resultobj = SWIG_Py_Void();
37484 return resultobj;
37485 fail:
37486 return NULL;
37487 }
37488
37489
37490 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37491 PyObject *resultobj = 0;
37492 wxWindow *arg1 = (wxWindow *) 0 ;
37493 bool result;
37494 void *argp1 = 0 ;
37495 int res1 = 0 ;
37496 PyObject *swig_obj[1] ;
37497
37498 if (!args) SWIG_fail;
37499 swig_obj[0] = args;
37500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37501 if (!SWIG_IsOK(res1)) {
37502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37503 }
37504 arg1 = reinterpret_cast< wxWindow * >(argp1);
37505 {
37506 PyThreadState* __tstate = wxPyBeginAllowThreads();
37507 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37508 wxPyEndAllowThreads(__tstate);
37509 if (PyErr_Occurred()) SWIG_fail;
37510 }
37511 {
37512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37513 }
37514 return resultobj;
37515 fail:
37516 return NULL;
37517 }
37518
37519
37520 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37521 PyObject *obj;
37522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37523 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37524 return SWIG_Py_Void();
37525 }
37526
37527 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37528 return SWIG_Python_InitShadowInstance(args);
37529 }
37530
37531 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37532 PyObject *resultobj = 0;
37533 long arg1 ;
37534 wxWindow *arg2 = (wxWindow *) NULL ;
37535 wxWindow *result = 0 ;
37536 long val1 ;
37537 int ecode1 = 0 ;
37538 void *argp2 = 0 ;
37539 int res2 = 0 ;
37540 PyObject * obj0 = 0 ;
37541 PyObject * obj1 = 0 ;
37542 char * kwnames[] = {
37543 (char *) "id",(char *) "parent", NULL
37544 };
37545
37546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37547 ecode1 = SWIG_AsVal_long(obj0, &val1);
37548 if (!SWIG_IsOK(ecode1)) {
37549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37550 }
37551 arg1 = static_cast< long >(val1);
37552 if (obj1) {
37553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37554 if (!SWIG_IsOK(res2)) {
37555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37556 }
37557 arg2 = reinterpret_cast< wxWindow * >(argp2);
37558 }
37559 {
37560 if (!wxPyCheckForApp()) SWIG_fail;
37561 PyThreadState* __tstate = wxPyBeginAllowThreads();
37562 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37563 wxPyEndAllowThreads(__tstate);
37564 if (PyErr_Occurred()) SWIG_fail;
37565 }
37566 {
37567 resultobj = wxPyMake_wxObject(result, 0);
37568 }
37569 return resultobj;
37570 fail:
37571 return NULL;
37572 }
37573
37574
37575 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37576 PyObject *resultobj = 0;
37577 wxString *arg1 = 0 ;
37578 wxWindow *arg2 = (wxWindow *) NULL ;
37579 wxWindow *result = 0 ;
37580 bool temp1 = false ;
37581 void *argp2 = 0 ;
37582 int res2 = 0 ;
37583 PyObject * obj0 = 0 ;
37584 PyObject * obj1 = 0 ;
37585 char * kwnames[] = {
37586 (char *) "name",(char *) "parent", NULL
37587 };
37588
37589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37590 {
37591 arg1 = wxString_in_helper(obj0);
37592 if (arg1 == NULL) SWIG_fail;
37593 temp1 = true;
37594 }
37595 if (obj1) {
37596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37597 if (!SWIG_IsOK(res2)) {
37598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37599 }
37600 arg2 = reinterpret_cast< wxWindow * >(argp2);
37601 }
37602 {
37603 if (!wxPyCheckForApp()) SWIG_fail;
37604 PyThreadState* __tstate = wxPyBeginAllowThreads();
37605 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37606 wxPyEndAllowThreads(__tstate);
37607 if (PyErr_Occurred()) SWIG_fail;
37608 }
37609 {
37610 resultobj = wxPyMake_wxObject(result, 0);
37611 }
37612 {
37613 if (temp1)
37614 delete arg1;
37615 }
37616 return resultobj;
37617 fail:
37618 {
37619 if (temp1)
37620 delete arg1;
37621 }
37622 return NULL;
37623 }
37624
37625
37626 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37627 PyObject *resultobj = 0;
37628 wxString *arg1 = 0 ;
37629 wxWindow *arg2 = (wxWindow *) NULL ;
37630 wxWindow *result = 0 ;
37631 bool temp1 = false ;
37632 void *argp2 = 0 ;
37633 int res2 = 0 ;
37634 PyObject * obj0 = 0 ;
37635 PyObject * obj1 = 0 ;
37636 char * kwnames[] = {
37637 (char *) "label",(char *) "parent", NULL
37638 };
37639
37640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37641 {
37642 arg1 = wxString_in_helper(obj0);
37643 if (arg1 == NULL) SWIG_fail;
37644 temp1 = true;
37645 }
37646 if (obj1) {
37647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37648 if (!SWIG_IsOK(res2)) {
37649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37650 }
37651 arg2 = reinterpret_cast< wxWindow * >(argp2);
37652 }
37653 {
37654 if (!wxPyCheckForApp()) SWIG_fail;
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37657 wxPyEndAllowThreads(__tstate);
37658 if (PyErr_Occurred()) SWIG_fail;
37659 }
37660 {
37661 resultobj = wxPyMake_wxObject(result, 0);
37662 }
37663 {
37664 if (temp1)
37665 delete arg1;
37666 }
37667 return resultobj;
37668 fail:
37669 {
37670 if (temp1)
37671 delete arg1;
37672 }
37673 return NULL;
37674 }
37675
37676
37677 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37678 PyObject *resultobj = 0;
37679 wxWindow *arg1 = (wxWindow *) 0 ;
37680 unsigned long arg2 ;
37681 wxWindow *result = 0 ;
37682 void *argp1 = 0 ;
37683 int res1 = 0 ;
37684 unsigned long val2 ;
37685 int ecode2 = 0 ;
37686 PyObject * obj0 = 0 ;
37687 PyObject * obj1 = 0 ;
37688 char * kwnames[] = {
37689 (char *) "parent",(char *) "_hWnd", NULL
37690 };
37691
37692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37694 if (!SWIG_IsOK(res1)) {
37695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37696 }
37697 arg1 = reinterpret_cast< wxWindow * >(argp1);
37698 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37699 if (!SWIG_IsOK(ecode2)) {
37700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37701 }
37702 arg2 = static_cast< unsigned long >(val2);
37703 {
37704 PyThreadState* __tstate = wxPyBeginAllowThreads();
37705 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37706 wxPyEndAllowThreads(__tstate);
37707 if (PyErr_Occurred()) SWIG_fail;
37708 }
37709 {
37710 resultobj = wxPyMake_wxObject(result, 0);
37711 }
37712 return resultobj;
37713 fail:
37714 return NULL;
37715 }
37716
37717
37718 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37719 PyObject *resultobj = 0;
37720 PyObject *result = 0 ;
37721
37722 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 result = (PyObject *)GetTopLevelWindows();
37726 wxPyEndAllowThreads(__tstate);
37727 if (PyErr_Occurred()) SWIG_fail;
37728 }
37729 resultobj = result;
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37737 PyObject *resultobj = 0;
37738 wxValidator *result = 0 ;
37739
37740 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37741 {
37742 PyThreadState* __tstate = wxPyBeginAllowThreads();
37743 result = (wxValidator *)new wxValidator();
37744 wxPyEndAllowThreads(__tstate);
37745 if (PyErr_Occurred()) SWIG_fail;
37746 }
37747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37748 return resultobj;
37749 fail:
37750 return NULL;
37751 }
37752
37753
37754 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37755 PyObject *resultobj = 0;
37756 wxValidator *arg1 = (wxValidator *) 0 ;
37757 wxValidator *result = 0 ;
37758 void *argp1 = 0 ;
37759 int res1 = 0 ;
37760 PyObject *swig_obj[1] ;
37761
37762 if (!args) SWIG_fail;
37763 swig_obj[0] = args;
37764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37765 if (!SWIG_IsOK(res1)) {
37766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37767 }
37768 arg1 = reinterpret_cast< wxValidator * >(argp1);
37769 {
37770 PyThreadState* __tstate = wxPyBeginAllowThreads();
37771 result = (wxValidator *)(arg1)->Clone();
37772 wxPyEndAllowThreads(__tstate);
37773 if (PyErr_Occurred()) SWIG_fail;
37774 }
37775 {
37776 resultobj = wxPyMake_wxObject(result, 0);
37777 }
37778 return resultobj;
37779 fail:
37780 return NULL;
37781 }
37782
37783
37784 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37785 PyObject *resultobj = 0;
37786 wxValidator *arg1 = (wxValidator *) 0 ;
37787 wxWindow *arg2 = (wxWindow *) 0 ;
37788 bool result;
37789 void *argp1 = 0 ;
37790 int res1 = 0 ;
37791 void *argp2 = 0 ;
37792 int res2 = 0 ;
37793 PyObject * obj0 = 0 ;
37794 PyObject * obj1 = 0 ;
37795 char * kwnames[] = {
37796 (char *) "self",(char *) "parent", NULL
37797 };
37798
37799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37801 if (!SWIG_IsOK(res1)) {
37802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37803 }
37804 arg1 = reinterpret_cast< wxValidator * >(argp1);
37805 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37806 if (!SWIG_IsOK(res2)) {
37807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37808 }
37809 arg2 = reinterpret_cast< wxWindow * >(argp2);
37810 {
37811 PyThreadState* __tstate = wxPyBeginAllowThreads();
37812 result = (bool)(arg1)->Validate(arg2);
37813 wxPyEndAllowThreads(__tstate);
37814 if (PyErr_Occurred()) SWIG_fail;
37815 }
37816 {
37817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37818 }
37819 return resultobj;
37820 fail:
37821 return NULL;
37822 }
37823
37824
37825 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37826 PyObject *resultobj = 0;
37827 wxValidator *arg1 = (wxValidator *) 0 ;
37828 bool result;
37829 void *argp1 = 0 ;
37830 int res1 = 0 ;
37831 PyObject *swig_obj[1] ;
37832
37833 if (!args) SWIG_fail;
37834 swig_obj[0] = args;
37835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37836 if (!SWIG_IsOK(res1)) {
37837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37838 }
37839 arg1 = reinterpret_cast< wxValidator * >(argp1);
37840 {
37841 PyThreadState* __tstate = wxPyBeginAllowThreads();
37842 result = (bool)(arg1)->TransferToWindow();
37843 wxPyEndAllowThreads(__tstate);
37844 if (PyErr_Occurred()) SWIG_fail;
37845 }
37846 {
37847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37848 }
37849 return resultobj;
37850 fail:
37851 return NULL;
37852 }
37853
37854
37855 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37856 PyObject *resultobj = 0;
37857 wxValidator *arg1 = (wxValidator *) 0 ;
37858 bool result;
37859 void *argp1 = 0 ;
37860 int res1 = 0 ;
37861 PyObject *swig_obj[1] ;
37862
37863 if (!args) SWIG_fail;
37864 swig_obj[0] = args;
37865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37866 if (!SWIG_IsOK(res1)) {
37867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37868 }
37869 arg1 = reinterpret_cast< wxValidator * >(argp1);
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 result = (bool)(arg1)->TransferFromWindow();
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 {
37877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37878 }
37879 return resultobj;
37880 fail:
37881 return NULL;
37882 }
37883
37884
37885 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37886 PyObject *resultobj = 0;
37887 wxValidator *arg1 = (wxValidator *) 0 ;
37888 wxWindow *result = 0 ;
37889 void *argp1 = 0 ;
37890 int res1 = 0 ;
37891 PyObject *swig_obj[1] ;
37892
37893 if (!args) SWIG_fail;
37894 swig_obj[0] = args;
37895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37896 if (!SWIG_IsOK(res1)) {
37897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37898 }
37899 arg1 = reinterpret_cast< wxValidator * >(argp1);
37900 {
37901 PyThreadState* __tstate = wxPyBeginAllowThreads();
37902 result = (wxWindow *)(arg1)->GetWindow();
37903 wxPyEndAllowThreads(__tstate);
37904 if (PyErr_Occurred()) SWIG_fail;
37905 }
37906 {
37907 resultobj = wxPyMake_wxObject(result, 0);
37908 }
37909 return resultobj;
37910 fail:
37911 return NULL;
37912 }
37913
37914
37915 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37916 PyObject *resultobj = 0;
37917 wxValidator *arg1 = (wxValidator *) 0 ;
37918 wxWindow *arg2 = (wxWindow *) 0 ;
37919 void *argp1 = 0 ;
37920 int res1 = 0 ;
37921 void *argp2 = 0 ;
37922 int res2 = 0 ;
37923 PyObject * obj0 = 0 ;
37924 PyObject * obj1 = 0 ;
37925 char * kwnames[] = {
37926 (char *) "self",(char *) "window", NULL
37927 };
37928
37929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37931 if (!SWIG_IsOK(res1)) {
37932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37933 }
37934 arg1 = reinterpret_cast< wxValidator * >(argp1);
37935 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37936 if (!SWIG_IsOK(res2)) {
37937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37938 }
37939 arg2 = reinterpret_cast< wxWindow * >(argp2);
37940 {
37941 PyThreadState* __tstate = wxPyBeginAllowThreads();
37942 (arg1)->SetWindow(arg2);
37943 wxPyEndAllowThreads(__tstate);
37944 if (PyErr_Occurred()) SWIG_fail;
37945 }
37946 resultobj = SWIG_Py_Void();
37947 return resultobj;
37948 fail:
37949 return NULL;
37950 }
37951
37952
37953 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37954 PyObject *resultobj = 0;
37955 bool result;
37956
37957 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37958 {
37959 PyThreadState* __tstate = wxPyBeginAllowThreads();
37960 result = (bool)wxValidator::IsSilent();
37961 wxPyEndAllowThreads(__tstate);
37962 if (PyErr_Occurred()) SWIG_fail;
37963 }
37964 {
37965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37966 }
37967 return resultobj;
37968 fail:
37969 return NULL;
37970 }
37971
37972
37973 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37974 PyObject *resultobj = 0;
37975 int arg1 = (int) true ;
37976 int val1 ;
37977 int ecode1 = 0 ;
37978 PyObject * obj0 = 0 ;
37979 char * kwnames[] = {
37980 (char *) "doIt", NULL
37981 };
37982
37983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37984 if (obj0) {
37985 ecode1 = SWIG_AsVal_int(obj0, &val1);
37986 if (!SWIG_IsOK(ecode1)) {
37987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37988 }
37989 arg1 = static_cast< int >(val1);
37990 }
37991 {
37992 PyThreadState* __tstate = wxPyBeginAllowThreads();
37993 wxValidator::SetBellOnError(arg1);
37994 wxPyEndAllowThreads(__tstate);
37995 if (PyErr_Occurred()) SWIG_fail;
37996 }
37997 resultobj = SWIG_Py_Void();
37998 return resultobj;
37999 fail:
38000 return NULL;
38001 }
38002
38003
38004 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38005 PyObject *obj;
38006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38007 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38008 return SWIG_Py_Void();
38009 }
38010
38011 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38012 return SWIG_Python_InitShadowInstance(args);
38013 }
38014
38015 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38016 PyObject *resultobj = 0;
38017 wxPyValidator *result = 0 ;
38018
38019 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38020 {
38021 PyThreadState* __tstate = wxPyBeginAllowThreads();
38022 result = (wxPyValidator *)new wxPyValidator();
38023 wxPyEndAllowThreads(__tstate);
38024 if (PyErr_Occurred()) SWIG_fail;
38025 }
38026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38027 return resultobj;
38028 fail:
38029 return NULL;
38030 }
38031
38032
38033 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38034 PyObject *resultobj = 0;
38035 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38036 PyObject *arg2 = (PyObject *) 0 ;
38037 PyObject *arg3 = (PyObject *) 0 ;
38038 int arg4 = (int) true ;
38039 void *argp1 = 0 ;
38040 int res1 = 0 ;
38041 int val4 ;
38042 int ecode4 = 0 ;
38043 PyObject * obj0 = 0 ;
38044 PyObject * obj1 = 0 ;
38045 PyObject * obj2 = 0 ;
38046 PyObject * obj3 = 0 ;
38047 char * kwnames[] = {
38048 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38049 };
38050
38051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38053 if (!SWIG_IsOK(res1)) {
38054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38055 }
38056 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38057 arg2 = obj1;
38058 arg3 = obj2;
38059 if (obj3) {
38060 ecode4 = SWIG_AsVal_int(obj3, &val4);
38061 if (!SWIG_IsOK(ecode4)) {
38062 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38063 }
38064 arg4 = static_cast< int >(val4);
38065 }
38066 {
38067 PyThreadState* __tstate = wxPyBeginAllowThreads();
38068 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38069 wxPyEndAllowThreads(__tstate);
38070 if (PyErr_Occurred()) SWIG_fail;
38071 }
38072 resultobj = SWIG_Py_Void();
38073 return resultobj;
38074 fail:
38075 return NULL;
38076 }
38077
38078
38079 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38080 PyObject *obj;
38081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38082 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38083 return SWIG_Py_Void();
38084 }
38085
38086 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38087 return SWIG_Python_InitShadowInstance(args);
38088 }
38089
38090 SWIGINTERN int DefaultValidator_set(PyObject *) {
38091 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38092 return 1;
38093 }
38094
38095
38096 SWIGINTERN PyObject *DefaultValidator_get(void) {
38097 PyObject *pyobj = 0;
38098
38099 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38100 return pyobj;
38101 }
38102
38103
38104 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38105 PyObject *resultobj = 0;
38106 wxString const &arg1_defvalue = wxPyEmptyString ;
38107 wxString *arg1 = (wxString *) &arg1_defvalue ;
38108 long arg2 = (long) 0 ;
38109 wxMenu *result = 0 ;
38110 bool temp1 = false ;
38111 long val2 ;
38112 int ecode2 = 0 ;
38113 PyObject * obj0 = 0 ;
38114 PyObject * obj1 = 0 ;
38115 char * kwnames[] = {
38116 (char *) "title",(char *) "style", NULL
38117 };
38118
38119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38120 if (obj0) {
38121 {
38122 arg1 = wxString_in_helper(obj0);
38123 if (arg1 == NULL) SWIG_fail;
38124 temp1 = true;
38125 }
38126 }
38127 if (obj1) {
38128 ecode2 = SWIG_AsVal_long(obj1, &val2);
38129 if (!SWIG_IsOK(ecode2)) {
38130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38131 }
38132 arg2 = static_cast< long >(val2);
38133 }
38134 {
38135 if (!wxPyCheckForApp()) SWIG_fail;
38136 PyThreadState* __tstate = wxPyBeginAllowThreads();
38137 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38138 wxPyEndAllowThreads(__tstate);
38139 if (PyErr_Occurred()) SWIG_fail;
38140 }
38141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38142 {
38143 if (temp1)
38144 delete arg1;
38145 }
38146 return resultobj;
38147 fail:
38148 {
38149 if (temp1)
38150 delete arg1;
38151 }
38152 return NULL;
38153 }
38154
38155
38156 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38157 PyObject *resultobj = 0;
38158 wxMenu *arg1 = (wxMenu *) 0 ;
38159 int arg2 ;
38160 wxString *arg3 = 0 ;
38161 wxString const &arg4_defvalue = wxPyEmptyString ;
38162 wxString *arg4 = (wxString *) &arg4_defvalue ;
38163 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38164 wxMenuItem *result = 0 ;
38165 void *argp1 = 0 ;
38166 int res1 = 0 ;
38167 int val2 ;
38168 int ecode2 = 0 ;
38169 bool temp3 = false ;
38170 bool temp4 = false ;
38171 int val5 ;
38172 int ecode5 = 0 ;
38173 PyObject * obj0 = 0 ;
38174 PyObject * obj1 = 0 ;
38175 PyObject * obj2 = 0 ;
38176 PyObject * obj3 = 0 ;
38177 PyObject * obj4 = 0 ;
38178 char * kwnames[] = {
38179 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38180 };
38181
38182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38184 if (!SWIG_IsOK(res1)) {
38185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38186 }
38187 arg1 = reinterpret_cast< wxMenu * >(argp1);
38188 ecode2 = SWIG_AsVal_int(obj1, &val2);
38189 if (!SWIG_IsOK(ecode2)) {
38190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38191 }
38192 arg2 = static_cast< int >(val2);
38193 {
38194 arg3 = wxString_in_helper(obj2);
38195 if (arg3 == NULL) SWIG_fail;
38196 temp3 = true;
38197 }
38198 if (obj3) {
38199 {
38200 arg4 = wxString_in_helper(obj3);
38201 if (arg4 == NULL) SWIG_fail;
38202 temp4 = true;
38203 }
38204 }
38205 if (obj4) {
38206 ecode5 = SWIG_AsVal_int(obj4, &val5);
38207 if (!SWIG_IsOK(ecode5)) {
38208 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38209 }
38210 arg5 = static_cast< wxItemKind >(val5);
38211 }
38212 {
38213 PyThreadState* __tstate = wxPyBeginAllowThreads();
38214 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38215 wxPyEndAllowThreads(__tstate);
38216 if (PyErr_Occurred()) SWIG_fail;
38217 }
38218 {
38219 resultobj = wxPyMake_wxObject(result, (bool)0);
38220 }
38221 {
38222 if (temp3)
38223 delete arg3;
38224 }
38225 {
38226 if (temp4)
38227 delete arg4;
38228 }
38229 return resultobj;
38230 fail:
38231 {
38232 if (temp3)
38233 delete arg3;
38234 }
38235 {
38236 if (temp4)
38237 delete arg4;
38238 }
38239 return NULL;
38240 }
38241
38242
38243 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38244 PyObject *resultobj = 0;
38245 wxMenu *arg1 = (wxMenu *) 0 ;
38246 wxMenuItem *result = 0 ;
38247 void *argp1 = 0 ;
38248 int res1 = 0 ;
38249 PyObject *swig_obj[1] ;
38250
38251 if (!args) SWIG_fail;
38252 swig_obj[0] = args;
38253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38254 if (!SWIG_IsOK(res1)) {
38255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38256 }
38257 arg1 = reinterpret_cast< wxMenu * >(argp1);
38258 {
38259 PyThreadState* __tstate = wxPyBeginAllowThreads();
38260 result = (wxMenuItem *)(arg1)->AppendSeparator();
38261 wxPyEndAllowThreads(__tstate);
38262 if (PyErr_Occurred()) SWIG_fail;
38263 }
38264 {
38265 resultobj = wxPyMake_wxObject(result, (bool)0);
38266 }
38267 return resultobj;
38268 fail:
38269 return NULL;
38270 }
38271
38272
38273 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38274 PyObject *resultobj = 0;
38275 wxMenu *arg1 = (wxMenu *) 0 ;
38276 int arg2 ;
38277 wxString *arg3 = 0 ;
38278 wxString const &arg4_defvalue = wxPyEmptyString ;
38279 wxString *arg4 = (wxString *) &arg4_defvalue ;
38280 wxMenuItem *result = 0 ;
38281 void *argp1 = 0 ;
38282 int res1 = 0 ;
38283 int val2 ;
38284 int ecode2 = 0 ;
38285 bool temp3 = false ;
38286 bool temp4 = false ;
38287 PyObject * obj0 = 0 ;
38288 PyObject * obj1 = 0 ;
38289 PyObject * obj2 = 0 ;
38290 PyObject * obj3 = 0 ;
38291 char * kwnames[] = {
38292 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38293 };
38294
38295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38297 if (!SWIG_IsOK(res1)) {
38298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38299 }
38300 arg1 = reinterpret_cast< wxMenu * >(argp1);
38301 ecode2 = SWIG_AsVal_int(obj1, &val2);
38302 if (!SWIG_IsOK(ecode2)) {
38303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38304 }
38305 arg2 = static_cast< int >(val2);
38306 {
38307 arg3 = wxString_in_helper(obj2);
38308 if (arg3 == NULL) SWIG_fail;
38309 temp3 = true;
38310 }
38311 if (obj3) {
38312 {
38313 arg4 = wxString_in_helper(obj3);
38314 if (arg4 == NULL) SWIG_fail;
38315 temp4 = true;
38316 }
38317 }
38318 {
38319 PyThreadState* __tstate = wxPyBeginAllowThreads();
38320 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38321 wxPyEndAllowThreads(__tstate);
38322 if (PyErr_Occurred()) SWIG_fail;
38323 }
38324 {
38325 resultobj = wxPyMake_wxObject(result, (bool)0);
38326 }
38327 {
38328 if (temp3)
38329 delete arg3;
38330 }
38331 {
38332 if (temp4)
38333 delete arg4;
38334 }
38335 return resultobj;
38336 fail:
38337 {
38338 if (temp3)
38339 delete arg3;
38340 }
38341 {
38342 if (temp4)
38343 delete arg4;
38344 }
38345 return NULL;
38346 }
38347
38348
38349 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38350 PyObject *resultobj = 0;
38351 wxMenu *arg1 = (wxMenu *) 0 ;
38352 int arg2 ;
38353 wxString *arg3 = 0 ;
38354 wxString const &arg4_defvalue = wxPyEmptyString ;
38355 wxString *arg4 = (wxString *) &arg4_defvalue ;
38356 wxMenuItem *result = 0 ;
38357 void *argp1 = 0 ;
38358 int res1 = 0 ;
38359 int val2 ;
38360 int ecode2 = 0 ;
38361 bool temp3 = false ;
38362 bool temp4 = false ;
38363 PyObject * obj0 = 0 ;
38364 PyObject * obj1 = 0 ;
38365 PyObject * obj2 = 0 ;
38366 PyObject * obj3 = 0 ;
38367 char * kwnames[] = {
38368 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38369 };
38370
38371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38373 if (!SWIG_IsOK(res1)) {
38374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38375 }
38376 arg1 = reinterpret_cast< wxMenu * >(argp1);
38377 ecode2 = SWIG_AsVal_int(obj1, &val2);
38378 if (!SWIG_IsOK(ecode2)) {
38379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38380 }
38381 arg2 = static_cast< int >(val2);
38382 {
38383 arg3 = wxString_in_helper(obj2);
38384 if (arg3 == NULL) SWIG_fail;
38385 temp3 = true;
38386 }
38387 if (obj3) {
38388 {
38389 arg4 = wxString_in_helper(obj3);
38390 if (arg4 == NULL) SWIG_fail;
38391 temp4 = true;
38392 }
38393 }
38394 {
38395 PyThreadState* __tstate = wxPyBeginAllowThreads();
38396 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38397 wxPyEndAllowThreads(__tstate);
38398 if (PyErr_Occurred()) SWIG_fail;
38399 }
38400 {
38401 resultobj = wxPyMake_wxObject(result, (bool)0);
38402 }
38403 {
38404 if (temp3)
38405 delete arg3;
38406 }
38407 {
38408 if (temp4)
38409 delete arg4;
38410 }
38411 return resultobj;
38412 fail:
38413 {
38414 if (temp3)
38415 delete arg3;
38416 }
38417 {
38418 if (temp4)
38419 delete arg4;
38420 }
38421 return NULL;
38422 }
38423
38424
38425 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38426 PyObject *resultobj = 0;
38427 wxMenu *arg1 = (wxMenu *) 0 ;
38428 int arg2 ;
38429 wxString *arg3 = 0 ;
38430 wxMenu *arg4 = (wxMenu *) 0 ;
38431 wxString const &arg5_defvalue = wxPyEmptyString ;
38432 wxString *arg5 = (wxString *) &arg5_defvalue ;
38433 wxMenuItem *result = 0 ;
38434 void *argp1 = 0 ;
38435 int res1 = 0 ;
38436 int val2 ;
38437 int ecode2 = 0 ;
38438 bool temp3 = false ;
38439 void *argp4 = 0 ;
38440 int res4 = 0 ;
38441 bool temp5 = false ;
38442 PyObject * obj0 = 0 ;
38443 PyObject * obj1 = 0 ;
38444 PyObject * obj2 = 0 ;
38445 PyObject * obj3 = 0 ;
38446 PyObject * obj4 = 0 ;
38447 char * kwnames[] = {
38448 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38449 };
38450
38451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38453 if (!SWIG_IsOK(res1)) {
38454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38455 }
38456 arg1 = reinterpret_cast< wxMenu * >(argp1);
38457 ecode2 = SWIG_AsVal_int(obj1, &val2);
38458 if (!SWIG_IsOK(ecode2)) {
38459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38460 }
38461 arg2 = static_cast< int >(val2);
38462 {
38463 arg3 = wxString_in_helper(obj2);
38464 if (arg3 == NULL) SWIG_fail;
38465 temp3 = true;
38466 }
38467 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38468 if (!SWIG_IsOK(res4)) {
38469 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38470 }
38471 arg4 = reinterpret_cast< wxMenu * >(argp4);
38472 if (obj4) {
38473 {
38474 arg5 = wxString_in_helper(obj4);
38475 if (arg5 == NULL) SWIG_fail;
38476 temp5 = true;
38477 }
38478 }
38479 {
38480 PyThreadState* __tstate = wxPyBeginAllowThreads();
38481 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38482 wxPyEndAllowThreads(__tstate);
38483 if (PyErr_Occurred()) SWIG_fail;
38484 }
38485 {
38486 resultobj = wxPyMake_wxObject(result, (bool)0);
38487 }
38488 {
38489 if (temp3)
38490 delete arg3;
38491 }
38492 {
38493 if (temp5)
38494 delete arg5;
38495 }
38496 return resultobj;
38497 fail:
38498 {
38499 if (temp3)
38500 delete arg3;
38501 }
38502 {
38503 if (temp5)
38504 delete arg5;
38505 }
38506 return NULL;
38507 }
38508
38509
38510 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38511 PyObject *resultobj = 0;
38512 wxMenu *arg1 = (wxMenu *) 0 ;
38513 wxMenu *arg2 = (wxMenu *) 0 ;
38514 wxString *arg3 = 0 ;
38515 wxString const &arg4_defvalue = wxPyEmptyString ;
38516 wxString *arg4 = (wxString *) &arg4_defvalue ;
38517 wxMenuItem *result = 0 ;
38518 void *argp1 = 0 ;
38519 int res1 = 0 ;
38520 void *argp2 = 0 ;
38521 int res2 = 0 ;
38522 bool temp3 = false ;
38523 bool temp4 = false ;
38524 PyObject * obj0 = 0 ;
38525 PyObject * obj1 = 0 ;
38526 PyObject * obj2 = 0 ;
38527 PyObject * obj3 = 0 ;
38528 char * kwnames[] = {
38529 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38530 };
38531
38532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38534 if (!SWIG_IsOK(res1)) {
38535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38536 }
38537 arg1 = reinterpret_cast< wxMenu * >(argp1);
38538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38539 if (!SWIG_IsOK(res2)) {
38540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38541 }
38542 arg2 = reinterpret_cast< wxMenu * >(argp2);
38543 {
38544 arg3 = wxString_in_helper(obj2);
38545 if (arg3 == NULL) SWIG_fail;
38546 temp3 = true;
38547 }
38548 if (obj3) {
38549 {
38550 arg4 = wxString_in_helper(obj3);
38551 if (arg4 == NULL) SWIG_fail;
38552 temp4 = true;
38553 }
38554 }
38555 {
38556 PyThreadState* __tstate = wxPyBeginAllowThreads();
38557 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38558 wxPyEndAllowThreads(__tstate);
38559 if (PyErr_Occurred()) SWIG_fail;
38560 }
38561 {
38562 resultobj = wxPyMake_wxObject(result, (bool)0);
38563 }
38564 {
38565 if (temp3)
38566 delete arg3;
38567 }
38568 {
38569 if (temp4)
38570 delete arg4;
38571 }
38572 return resultobj;
38573 fail:
38574 {
38575 if (temp3)
38576 delete arg3;
38577 }
38578 {
38579 if (temp4)
38580 delete arg4;
38581 }
38582 return NULL;
38583 }
38584
38585
38586 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38587 PyObject *resultobj = 0;
38588 wxMenu *arg1 = (wxMenu *) 0 ;
38589 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38590 wxMenuItem *result = 0 ;
38591 void *argp1 = 0 ;
38592 int res1 = 0 ;
38593 int res2 = 0 ;
38594 PyObject * obj0 = 0 ;
38595 PyObject * obj1 = 0 ;
38596 char * kwnames[] = {
38597 (char *) "self",(char *) "item", NULL
38598 };
38599
38600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38602 if (!SWIG_IsOK(res1)) {
38603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38604 }
38605 arg1 = reinterpret_cast< wxMenu * >(argp1);
38606 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38607 if (!SWIG_IsOK(res2)) {
38608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38609 }
38610 {
38611 PyThreadState* __tstate = wxPyBeginAllowThreads();
38612 result = (wxMenuItem *)(arg1)->Append(arg2);
38613 wxPyEndAllowThreads(__tstate);
38614 if (PyErr_Occurred()) SWIG_fail;
38615 }
38616 {
38617 resultobj = wxPyMake_wxObject(result, (bool)0);
38618 }
38619 return resultobj;
38620 fail:
38621 return NULL;
38622 }
38623
38624
38625 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38626 PyObject *resultobj = 0;
38627 wxMenu *arg1 = (wxMenu *) 0 ;
38628 size_t arg2 ;
38629 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38630 wxMenuItem *result = 0 ;
38631 void *argp1 = 0 ;
38632 int res1 = 0 ;
38633 size_t val2 ;
38634 int ecode2 = 0 ;
38635 int res3 = 0 ;
38636 PyObject * obj0 = 0 ;
38637 PyObject * obj1 = 0 ;
38638 PyObject * obj2 = 0 ;
38639 char * kwnames[] = {
38640 (char *) "self",(char *) "pos",(char *) "item", NULL
38641 };
38642
38643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38645 if (!SWIG_IsOK(res1)) {
38646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38647 }
38648 arg1 = reinterpret_cast< wxMenu * >(argp1);
38649 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38650 if (!SWIG_IsOK(ecode2)) {
38651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38652 }
38653 arg2 = static_cast< size_t >(val2);
38654 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38655 if (!SWIG_IsOK(res3)) {
38656 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38657 }
38658 {
38659 PyThreadState* __tstate = wxPyBeginAllowThreads();
38660 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38661 wxPyEndAllowThreads(__tstate);
38662 if (PyErr_Occurred()) SWIG_fail;
38663 }
38664 {
38665 resultobj = wxPyMake_wxObject(result, (bool)0);
38666 }
38667 return resultobj;
38668 fail:
38669 return NULL;
38670 }
38671
38672
38673 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38674 PyObject *resultobj = 0;
38675 wxMenu *arg1 = (wxMenu *) 0 ;
38676 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38677 wxMenuItem *result = 0 ;
38678 void *argp1 = 0 ;
38679 int res1 = 0 ;
38680 int res2 = 0 ;
38681 PyObject * obj0 = 0 ;
38682 PyObject * obj1 = 0 ;
38683 char * kwnames[] = {
38684 (char *) "self",(char *) "item", NULL
38685 };
38686
38687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38689 if (!SWIG_IsOK(res1)) {
38690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38691 }
38692 arg1 = reinterpret_cast< wxMenu * >(argp1);
38693 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38694 if (!SWIG_IsOK(res2)) {
38695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38696 }
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 {
38704 resultobj = wxPyMake_wxObject(result, (bool)0);
38705 }
38706 return resultobj;
38707 fail:
38708 return NULL;
38709 }
38710
38711
38712 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38713 PyObject *resultobj = 0;
38714 wxMenu *arg1 = (wxMenu *) 0 ;
38715 void *argp1 = 0 ;
38716 int res1 = 0 ;
38717 PyObject *swig_obj[1] ;
38718
38719 if (!args) SWIG_fail;
38720 swig_obj[0] = args;
38721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38722 if (!SWIG_IsOK(res1)) {
38723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38724 }
38725 arg1 = reinterpret_cast< wxMenu * >(argp1);
38726 {
38727 PyThreadState* __tstate = wxPyBeginAllowThreads();
38728 (arg1)->Break();
38729 wxPyEndAllowThreads(__tstate);
38730 if (PyErr_Occurred()) SWIG_fail;
38731 }
38732 resultobj = SWIG_Py_Void();
38733 return resultobj;
38734 fail:
38735 return NULL;
38736 }
38737
38738
38739 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38740 PyObject *resultobj = 0;
38741 wxMenu *arg1 = (wxMenu *) 0 ;
38742 size_t arg2 ;
38743 int arg3 ;
38744 wxString *arg4 = 0 ;
38745 wxString const &arg5_defvalue = wxPyEmptyString ;
38746 wxString *arg5 = (wxString *) &arg5_defvalue ;
38747 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38748 wxMenuItem *result = 0 ;
38749 void *argp1 = 0 ;
38750 int res1 = 0 ;
38751 size_t val2 ;
38752 int ecode2 = 0 ;
38753 int val3 ;
38754 int ecode3 = 0 ;
38755 bool temp4 = false ;
38756 bool temp5 = false ;
38757 int val6 ;
38758 int ecode6 = 0 ;
38759 PyObject * obj0 = 0 ;
38760 PyObject * obj1 = 0 ;
38761 PyObject * obj2 = 0 ;
38762 PyObject * obj3 = 0 ;
38763 PyObject * obj4 = 0 ;
38764 PyObject * obj5 = 0 ;
38765 char * kwnames[] = {
38766 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38767 };
38768
38769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38771 if (!SWIG_IsOK(res1)) {
38772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38773 }
38774 arg1 = reinterpret_cast< wxMenu * >(argp1);
38775 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38776 if (!SWIG_IsOK(ecode2)) {
38777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38778 }
38779 arg2 = static_cast< size_t >(val2);
38780 ecode3 = SWIG_AsVal_int(obj2, &val3);
38781 if (!SWIG_IsOK(ecode3)) {
38782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38783 }
38784 arg3 = static_cast< int >(val3);
38785 {
38786 arg4 = wxString_in_helper(obj3);
38787 if (arg4 == NULL) SWIG_fail;
38788 temp4 = true;
38789 }
38790 if (obj4) {
38791 {
38792 arg5 = wxString_in_helper(obj4);
38793 if (arg5 == NULL) SWIG_fail;
38794 temp5 = true;
38795 }
38796 }
38797 if (obj5) {
38798 ecode6 = SWIG_AsVal_int(obj5, &val6);
38799 if (!SWIG_IsOK(ecode6)) {
38800 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38801 }
38802 arg6 = static_cast< wxItemKind >(val6);
38803 }
38804 {
38805 PyThreadState* __tstate = wxPyBeginAllowThreads();
38806 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38807 wxPyEndAllowThreads(__tstate);
38808 if (PyErr_Occurred()) SWIG_fail;
38809 }
38810 {
38811 resultobj = wxPyMake_wxObject(result, (bool)0);
38812 }
38813 {
38814 if (temp4)
38815 delete arg4;
38816 }
38817 {
38818 if (temp5)
38819 delete arg5;
38820 }
38821 return resultobj;
38822 fail:
38823 {
38824 if (temp4)
38825 delete arg4;
38826 }
38827 {
38828 if (temp5)
38829 delete arg5;
38830 }
38831 return NULL;
38832 }
38833
38834
38835 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38836 PyObject *resultobj = 0;
38837 wxMenu *arg1 = (wxMenu *) 0 ;
38838 size_t arg2 ;
38839 wxMenuItem *result = 0 ;
38840 void *argp1 = 0 ;
38841 int res1 = 0 ;
38842 size_t val2 ;
38843 int ecode2 = 0 ;
38844 PyObject * obj0 = 0 ;
38845 PyObject * obj1 = 0 ;
38846 char * kwnames[] = {
38847 (char *) "self",(char *) "pos", NULL
38848 };
38849
38850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38852 if (!SWIG_IsOK(res1)) {
38853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38854 }
38855 arg1 = reinterpret_cast< wxMenu * >(argp1);
38856 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38857 if (!SWIG_IsOK(ecode2)) {
38858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38859 }
38860 arg2 = static_cast< size_t >(val2);
38861 {
38862 PyThreadState* __tstate = wxPyBeginAllowThreads();
38863 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38864 wxPyEndAllowThreads(__tstate);
38865 if (PyErr_Occurred()) SWIG_fail;
38866 }
38867 {
38868 resultobj = wxPyMake_wxObject(result, (bool)0);
38869 }
38870 return resultobj;
38871 fail:
38872 return NULL;
38873 }
38874
38875
38876 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38877 PyObject *resultobj = 0;
38878 wxMenu *arg1 = (wxMenu *) 0 ;
38879 size_t arg2 ;
38880 int arg3 ;
38881 wxString *arg4 = 0 ;
38882 wxString const &arg5_defvalue = wxPyEmptyString ;
38883 wxString *arg5 = (wxString *) &arg5_defvalue ;
38884 wxMenuItem *result = 0 ;
38885 void *argp1 = 0 ;
38886 int res1 = 0 ;
38887 size_t val2 ;
38888 int ecode2 = 0 ;
38889 int val3 ;
38890 int ecode3 = 0 ;
38891 bool temp4 = false ;
38892 bool temp5 = false ;
38893 PyObject * obj0 = 0 ;
38894 PyObject * obj1 = 0 ;
38895 PyObject * obj2 = 0 ;
38896 PyObject * obj3 = 0 ;
38897 PyObject * obj4 = 0 ;
38898 char * kwnames[] = {
38899 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38900 };
38901
38902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38904 if (!SWIG_IsOK(res1)) {
38905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38906 }
38907 arg1 = reinterpret_cast< wxMenu * >(argp1);
38908 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38909 if (!SWIG_IsOK(ecode2)) {
38910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38911 }
38912 arg2 = static_cast< size_t >(val2);
38913 ecode3 = SWIG_AsVal_int(obj2, &val3);
38914 if (!SWIG_IsOK(ecode3)) {
38915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38916 }
38917 arg3 = static_cast< int >(val3);
38918 {
38919 arg4 = wxString_in_helper(obj3);
38920 if (arg4 == NULL) SWIG_fail;
38921 temp4 = true;
38922 }
38923 if (obj4) {
38924 {
38925 arg5 = wxString_in_helper(obj4);
38926 if (arg5 == NULL) SWIG_fail;
38927 temp5 = true;
38928 }
38929 }
38930 {
38931 PyThreadState* __tstate = wxPyBeginAllowThreads();
38932 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38933 wxPyEndAllowThreads(__tstate);
38934 if (PyErr_Occurred()) SWIG_fail;
38935 }
38936 {
38937 resultobj = wxPyMake_wxObject(result, (bool)0);
38938 }
38939 {
38940 if (temp4)
38941 delete arg4;
38942 }
38943 {
38944 if (temp5)
38945 delete arg5;
38946 }
38947 return resultobj;
38948 fail:
38949 {
38950 if (temp4)
38951 delete arg4;
38952 }
38953 {
38954 if (temp5)
38955 delete arg5;
38956 }
38957 return NULL;
38958 }
38959
38960
38961 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38962 PyObject *resultobj = 0;
38963 wxMenu *arg1 = (wxMenu *) 0 ;
38964 size_t arg2 ;
38965 int arg3 ;
38966 wxString *arg4 = 0 ;
38967 wxString const &arg5_defvalue = wxPyEmptyString ;
38968 wxString *arg5 = (wxString *) &arg5_defvalue ;
38969 wxMenuItem *result = 0 ;
38970 void *argp1 = 0 ;
38971 int res1 = 0 ;
38972 size_t val2 ;
38973 int ecode2 = 0 ;
38974 int val3 ;
38975 int ecode3 = 0 ;
38976 bool temp4 = false ;
38977 bool temp5 = false ;
38978 PyObject * obj0 = 0 ;
38979 PyObject * obj1 = 0 ;
38980 PyObject * obj2 = 0 ;
38981 PyObject * obj3 = 0 ;
38982 PyObject * obj4 = 0 ;
38983 char * kwnames[] = {
38984 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38985 };
38986
38987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38989 if (!SWIG_IsOK(res1)) {
38990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38991 }
38992 arg1 = reinterpret_cast< wxMenu * >(argp1);
38993 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38994 if (!SWIG_IsOK(ecode2)) {
38995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38996 }
38997 arg2 = static_cast< size_t >(val2);
38998 ecode3 = SWIG_AsVal_int(obj2, &val3);
38999 if (!SWIG_IsOK(ecode3)) {
39000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39001 }
39002 arg3 = static_cast< int >(val3);
39003 {
39004 arg4 = wxString_in_helper(obj3);
39005 if (arg4 == NULL) SWIG_fail;
39006 temp4 = true;
39007 }
39008 if (obj4) {
39009 {
39010 arg5 = wxString_in_helper(obj4);
39011 if (arg5 == NULL) SWIG_fail;
39012 temp5 = true;
39013 }
39014 }
39015 {
39016 PyThreadState* __tstate = wxPyBeginAllowThreads();
39017 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39018 wxPyEndAllowThreads(__tstate);
39019 if (PyErr_Occurred()) SWIG_fail;
39020 }
39021 {
39022 resultobj = wxPyMake_wxObject(result, (bool)0);
39023 }
39024 {
39025 if (temp4)
39026 delete arg4;
39027 }
39028 {
39029 if (temp5)
39030 delete arg5;
39031 }
39032 return resultobj;
39033 fail:
39034 {
39035 if (temp4)
39036 delete arg4;
39037 }
39038 {
39039 if (temp5)
39040 delete arg5;
39041 }
39042 return NULL;
39043 }
39044
39045
39046 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39047 PyObject *resultobj = 0;
39048 wxMenu *arg1 = (wxMenu *) 0 ;
39049 size_t arg2 ;
39050 int arg3 ;
39051 wxString *arg4 = 0 ;
39052 wxMenu *arg5 = (wxMenu *) 0 ;
39053 wxString const &arg6_defvalue = wxPyEmptyString ;
39054 wxString *arg6 = (wxString *) &arg6_defvalue ;
39055 wxMenuItem *result = 0 ;
39056 void *argp1 = 0 ;
39057 int res1 = 0 ;
39058 size_t val2 ;
39059 int ecode2 = 0 ;
39060 int val3 ;
39061 int ecode3 = 0 ;
39062 bool temp4 = false ;
39063 void *argp5 = 0 ;
39064 int res5 = 0 ;
39065 bool temp6 = false ;
39066 PyObject * obj0 = 0 ;
39067 PyObject * obj1 = 0 ;
39068 PyObject * obj2 = 0 ;
39069 PyObject * obj3 = 0 ;
39070 PyObject * obj4 = 0 ;
39071 PyObject * obj5 = 0 ;
39072 char * kwnames[] = {
39073 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39074 };
39075
39076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39078 if (!SWIG_IsOK(res1)) {
39079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39080 }
39081 arg1 = reinterpret_cast< wxMenu * >(argp1);
39082 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39083 if (!SWIG_IsOK(ecode2)) {
39084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39085 }
39086 arg2 = static_cast< size_t >(val2);
39087 ecode3 = SWIG_AsVal_int(obj2, &val3);
39088 if (!SWIG_IsOK(ecode3)) {
39089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39090 }
39091 arg3 = static_cast< int >(val3);
39092 {
39093 arg4 = wxString_in_helper(obj3);
39094 if (arg4 == NULL) SWIG_fail;
39095 temp4 = true;
39096 }
39097 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39098 if (!SWIG_IsOK(res5)) {
39099 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39100 }
39101 arg5 = reinterpret_cast< wxMenu * >(argp5);
39102 if (obj5) {
39103 {
39104 arg6 = wxString_in_helper(obj5);
39105 if (arg6 == NULL) SWIG_fail;
39106 temp6 = true;
39107 }
39108 }
39109 {
39110 PyThreadState* __tstate = wxPyBeginAllowThreads();
39111 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39112 wxPyEndAllowThreads(__tstate);
39113 if (PyErr_Occurred()) SWIG_fail;
39114 }
39115 {
39116 resultobj = wxPyMake_wxObject(result, (bool)0);
39117 }
39118 {
39119 if (temp4)
39120 delete arg4;
39121 }
39122 {
39123 if (temp6)
39124 delete arg6;
39125 }
39126 return resultobj;
39127 fail:
39128 {
39129 if (temp4)
39130 delete arg4;
39131 }
39132 {
39133 if (temp6)
39134 delete arg6;
39135 }
39136 return NULL;
39137 }
39138
39139
39140 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39141 PyObject *resultobj = 0;
39142 wxMenu *arg1 = (wxMenu *) 0 ;
39143 int arg2 ;
39144 wxString *arg3 = 0 ;
39145 wxString const &arg4_defvalue = wxPyEmptyString ;
39146 wxString *arg4 = (wxString *) &arg4_defvalue ;
39147 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39148 wxMenuItem *result = 0 ;
39149 void *argp1 = 0 ;
39150 int res1 = 0 ;
39151 int val2 ;
39152 int ecode2 = 0 ;
39153 bool temp3 = false ;
39154 bool temp4 = false ;
39155 int val5 ;
39156 int ecode5 = 0 ;
39157 PyObject * obj0 = 0 ;
39158 PyObject * obj1 = 0 ;
39159 PyObject * obj2 = 0 ;
39160 PyObject * obj3 = 0 ;
39161 PyObject * obj4 = 0 ;
39162 char * kwnames[] = {
39163 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39164 };
39165
39166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39168 if (!SWIG_IsOK(res1)) {
39169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39170 }
39171 arg1 = reinterpret_cast< wxMenu * >(argp1);
39172 ecode2 = SWIG_AsVal_int(obj1, &val2);
39173 if (!SWIG_IsOK(ecode2)) {
39174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39175 }
39176 arg2 = static_cast< int >(val2);
39177 {
39178 arg3 = wxString_in_helper(obj2);
39179 if (arg3 == NULL) SWIG_fail;
39180 temp3 = true;
39181 }
39182 if (obj3) {
39183 {
39184 arg4 = wxString_in_helper(obj3);
39185 if (arg4 == NULL) SWIG_fail;
39186 temp4 = true;
39187 }
39188 }
39189 if (obj4) {
39190 ecode5 = SWIG_AsVal_int(obj4, &val5);
39191 if (!SWIG_IsOK(ecode5)) {
39192 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39193 }
39194 arg5 = static_cast< wxItemKind >(val5);
39195 }
39196 {
39197 PyThreadState* __tstate = wxPyBeginAllowThreads();
39198 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39199 wxPyEndAllowThreads(__tstate);
39200 if (PyErr_Occurred()) SWIG_fail;
39201 }
39202 {
39203 resultobj = wxPyMake_wxObject(result, (bool)0);
39204 }
39205 {
39206 if (temp3)
39207 delete arg3;
39208 }
39209 {
39210 if (temp4)
39211 delete arg4;
39212 }
39213 return resultobj;
39214 fail:
39215 {
39216 if (temp3)
39217 delete arg3;
39218 }
39219 {
39220 if (temp4)
39221 delete arg4;
39222 }
39223 return NULL;
39224 }
39225
39226
39227 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39228 PyObject *resultobj = 0;
39229 wxMenu *arg1 = (wxMenu *) 0 ;
39230 wxMenuItem *result = 0 ;
39231 void *argp1 = 0 ;
39232 int res1 = 0 ;
39233 PyObject *swig_obj[1] ;
39234
39235 if (!args) SWIG_fail;
39236 swig_obj[0] = args;
39237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39238 if (!SWIG_IsOK(res1)) {
39239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39240 }
39241 arg1 = reinterpret_cast< wxMenu * >(argp1);
39242 {
39243 PyThreadState* __tstate = wxPyBeginAllowThreads();
39244 result = (wxMenuItem *)(arg1)->PrependSeparator();
39245 wxPyEndAllowThreads(__tstate);
39246 if (PyErr_Occurred()) SWIG_fail;
39247 }
39248 {
39249 resultobj = wxPyMake_wxObject(result, (bool)0);
39250 }
39251 return resultobj;
39252 fail:
39253 return NULL;
39254 }
39255
39256
39257 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39258 PyObject *resultobj = 0;
39259 wxMenu *arg1 = (wxMenu *) 0 ;
39260 int arg2 ;
39261 wxString *arg3 = 0 ;
39262 wxString const &arg4_defvalue = wxPyEmptyString ;
39263 wxString *arg4 = (wxString *) &arg4_defvalue ;
39264 wxMenuItem *result = 0 ;
39265 void *argp1 = 0 ;
39266 int res1 = 0 ;
39267 int val2 ;
39268 int ecode2 = 0 ;
39269 bool temp3 = false ;
39270 bool temp4 = false ;
39271 PyObject * obj0 = 0 ;
39272 PyObject * obj1 = 0 ;
39273 PyObject * obj2 = 0 ;
39274 PyObject * obj3 = 0 ;
39275 char * kwnames[] = {
39276 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39277 };
39278
39279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39281 if (!SWIG_IsOK(res1)) {
39282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39283 }
39284 arg1 = reinterpret_cast< wxMenu * >(argp1);
39285 ecode2 = SWIG_AsVal_int(obj1, &val2);
39286 if (!SWIG_IsOK(ecode2)) {
39287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39288 }
39289 arg2 = static_cast< int >(val2);
39290 {
39291 arg3 = wxString_in_helper(obj2);
39292 if (arg3 == NULL) SWIG_fail;
39293 temp3 = true;
39294 }
39295 if (obj3) {
39296 {
39297 arg4 = wxString_in_helper(obj3);
39298 if (arg4 == NULL) SWIG_fail;
39299 temp4 = true;
39300 }
39301 }
39302 {
39303 PyThreadState* __tstate = wxPyBeginAllowThreads();
39304 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39305 wxPyEndAllowThreads(__tstate);
39306 if (PyErr_Occurred()) SWIG_fail;
39307 }
39308 {
39309 resultobj = wxPyMake_wxObject(result, (bool)0);
39310 }
39311 {
39312 if (temp3)
39313 delete arg3;
39314 }
39315 {
39316 if (temp4)
39317 delete arg4;
39318 }
39319 return resultobj;
39320 fail:
39321 {
39322 if (temp3)
39323 delete arg3;
39324 }
39325 {
39326 if (temp4)
39327 delete arg4;
39328 }
39329 return NULL;
39330 }
39331
39332
39333 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39334 PyObject *resultobj = 0;
39335 wxMenu *arg1 = (wxMenu *) 0 ;
39336 int arg2 ;
39337 wxString *arg3 = 0 ;
39338 wxString const &arg4_defvalue = wxPyEmptyString ;
39339 wxString *arg4 = (wxString *) &arg4_defvalue ;
39340 wxMenuItem *result = 0 ;
39341 void *argp1 = 0 ;
39342 int res1 = 0 ;
39343 int val2 ;
39344 int ecode2 = 0 ;
39345 bool temp3 = false ;
39346 bool temp4 = false ;
39347 PyObject * obj0 = 0 ;
39348 PyObject * obj1 = 0 ;
39349 PyObject * obj2 = 0 ;
39350 PyObject * obj3 = 0 ;
39351 char * kwnames[] = {
39352 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39353 };
39354
39355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39357 if (!SWIG_IsOK(res1)) {
39358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39359 }
39360 arg1 = reinterpret_cast< wxMenu * >(argp1);
39361 ecode2 = SWIG_AsVal_int(obj1, &val2);
39362 if (!SWIG_IsOK(ecode2)) {
39363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39364 }
39365 arg2 = static_cast< int >(val2);
39366 {
39367 arg3 = wxString_in_helper(obj2);
39368 if (arg3 == NULL) SWIG_fail;
39369 temp3 = true;
39370 }
39371 if (obj3) {
39372 {
39373 arg4 = wxString_in_helper(obj3);
39374 if (arg4 == NULL) SWIG_fail;
39375 temp4 = true;
39376 }
39377 }
39378 {
39379 PyThreadState* __tstate = wxPyBeginAllowThreads();
39380 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39381 wxPyEndAllowThreads(__tstate);
39382 if (PyErr_Occurred()) SWIG_fail;
39383 }
39384 {
39385 resultobj = wxPyMake_wxObject(result, (bool)0);
39386 }
39387 {
39388 if (temp3)
39389 delete arg3;
39390 }
39391 {
39392 if (temp4)
39393 delete arg4;
39394 }
39395 return resultobj;
39396 fail:
39397 {
39398 if (temp3)
39399 delete arg3;
39400 }
39401 {
39402 if (temp4)
39403 delete arg4;
39404 }
39405 return NULL;
39406 }
39407
39408
39409 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39410 PyObject *resultobj = 0;
39411 wxMenu *arg1 = (wxMenu *) 0 ;
39412 int arg2 ;
39413 wxString *arg3 = 0 ;
39414 wxMenu *arg4 = (wxMenu *) 0 ;
39415 wxString const &arg5_defvalue = wxPyEmptyString ;
39416 wxString *arg5 = (wxString *) &arg5_defvalue ;
39417 wxMenuItem *result = 0 ;
39418 void *argp1 = 0 ;
39419 int res1 = 0 ;
39420 int val2 ;
39421 int ecode2 = 0 ;
39422 bool temp3 = false ;
39423 void *argp4 = 0 ;
39424 int res4 = 0 ;
39425 bool temp5 = false ;
39426 PyObject * obj0 = 0 ;
39427 PyObject * obj1 = 0 ;
39428 PyObject * obj2 = 0 ;
39429 PyObject * obj3 = 0 ;
39430 PyObject * obj4 = 0 ;
39431 char * kwnames[] = {
39432 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39433 };
39434
39435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39437 if (!SWIG_IsOK(res1)) {
39438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39439 }
39440 arg1 = reinterpret_cast< wxMenu * >(argp1);
39441 ecode2 = SWIG_AsVal_int(obj1, &val2);
39442 if (!SWIG_IsOK(ecode2)) {
39443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39444 }
39445 arg2 = static_cast< int >(val2);
39446 {
39447 arg3 = wxString_in_helper(obj2);
39448 if (arg3 == NULL) SWIG_fail;
39449 temp3 = true;
39450 }
39451 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39452 if (!SWIG_IsOK(res4)) {
39453 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39454 }
39455 arg4 = reinterpret_cast< wxMenu * >(argp4);
39456 if (obj4) {
39457 {
39458 arg5 = wxString_in_helper(obj4);
39459 if (arg5 == NULL) SWIG_fail;
39460 temp5 = true;
39461 }
39462 }
39463 {
39464 PyThreadState* __tstate = wxPyBeginAllowThreads();
39465 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39466 wxPyEndAllowThreads(__tstate);
39467 if (PyErr_Occurred()) SWIG_fail;
39468 }
39469 {
39470 resultobj = wxPyMake_wxObject(result, (bool)0);
39471 }
39472 {
39473 if (temp3)
39474 delete arg3;
39475 }
39476 {
39477 if (temp5)
39478 delete arg5;
39479 }
39480 return resultobj;
39481 fail:
39482 {
39483 if (temp3)
39484 delete arg3;
39485 }
39486 {
39487 if (temp5)
39488 delete arg5;
39489 }
39490 return NULL;
39491 }
39492
39493
39494 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39495 PyObject *resultobj = 0;
39496 wxMenu *arg1 = (wxMenu *) 0 ;
39497 int arg2 ;
39498 wxMenuItem *result = 0 ;
39499 void *argp1 = 0 ;
39500 int res1 = 0 ;
39501 int val2 ;
39502 int ecode2 = 0 ;
39503 PyObject * obj0 = 0 ;
39504 PyObject * obj1 = 0 ;
39505 char * kwnames[] = {
39506 (char *) "self",(char *) "id", NULL
39507 };
39508
39509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39511 if (!SWIG_IsOK(res1)) {
39512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39513 }
39514 arg1 = reinterpret_cast< wxMenu * >(argp1);
39515 ecode2 = SWIG_AsVal_int(obj1, &val2);
39516 if (!SWIG_IsOK(ecode2)) {
39517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39518 }
39519 arg2 = static_cast< int >(val2);
39520 {
39521 PyThreadState* __tstate = wxPyBeginAllowThreads();
39522 result = (wxMenuItem *)(arg1)->Remove(arg2);
39523 wxPyEndAllowThreads(__tstate);
39524 if (PyErr_Occurred()) SWIG_fail;
39525 }
39526 {
39527 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39528 }
39529 return resultobj;
39530 fail:
39531 return NULL;
39532 }
39533
39534
39535 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39536 PyObject *resultobj = 0;
39537 wxMenu *arg1 = (wxMenu *) 0 ;
39538 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39539 wxMenuItem *result = 0 ;
39540 void *argp1 = 0 ;
39541 int res1 = 0 ;
39542 void *argp2 = 0 ;
39543 int res2 = 0 ;
39544 PyObject * obj0 = 0 ;
39545 PyObject * obj1 = 0 ;
39546 char * kwnames[] = {
39547 (char *) "self",(char *) "item", NULL
39548 };
39549
39550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39552 if (!SWIG_IsOK(res1)) {
39553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39554 }
39555 arg1 = reinterpret_cast< wxMenu * >(argp1);
39556 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39557 if (!SWIG_IsOK(res2)) {
39558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39559 }
39560 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39561 {
39562 PyThreadState* __tstate = wxPyBeginAllowThreads();
39563 result = (wxMenuItem *)(arg1)->Remove(arg2);
39564 wxPyEndAllowThreads(__tstate);
39565 if (PyErr_Occurred()) SWIG_fail;
39566 }
39567 {
39568 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39569 }
39570 return resultobj;
39571 fail:
39572 return NULL;
39573 }
39574
39575
39576 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39577 PyObject *resultobj = 0;
39578 wxMenu *arg1 = (wxMenu *) 0 ;
39579 int arg2 ;
39580 bool result;
39581 void *argp1 = 0 ;
39582 int res1 = 0 ;
39583 int val2 ;
39584 int ecode2 = 0 ;
39585 PyObject * obj0 = 0 ;
39586 PyObject * obj1 = 0 ;
39587 char * kwnames[] = {
39588 (char *) "self",(char *) "id", NULL
39589 };
39590
39591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39593 if (!SWIG_IsOK(res1)) {
39594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39595 }
39596 arg1 = reinterpret_cast< wxMenu * >(argp1);
39597 ecode2 = SWIG_AsVal_int(obj1, &val2);
39598 if (!SWIG_IsOK(ecode2)) {
39599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39600 }
39601 arg2 = static_cast< int >(val2);
39602 {
39603 PyThreadState* __tstate = wxPyBeginAllowThreads();
39604 result = (bool)(arg1)->Delete(arg2);
39605 wxPyEndAllowThreads(__tstate);
39606 if (PyErr_Occurred()) SWIG_fail;
39607 }
39608 {
39609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39610 }
39611 return resultobj;
39612 fail:
39613 return NULL;
39614 }
39615
39616
39617 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39618 PyObject *resultobj = 0;
39619 wxMenu *arg1 = (wxMenu *) 0 ;
39620 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39621 bool result;
39622 void *argp1 = 0 ;
39623 int res1 = 0 ;
39624 void *argp2 = 0 ;
39625 int res2 = 0 ;
39626 PyObject * obj0 = 0 ;
39627 PyObject * obj1 = 0 ;
39628 char * kwnames[] = {
39629 (char *) "self",(char *) "item", NULL
39630 };
39631
39632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39634 if (!SWIG_IsOK(res1)) {
39635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39636 }
39637 arg1 = reinterpret_cast< wxMenu * >(argp1);
39638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39639 if (!SWIG_IsOK(res2)) {
39640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39641 }
39642 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39643 {
39644 PyThreadState* __tstate = wxPyBeginAllowThreads();
39645 result = (bool)(arg1)->Delete(arg2);
39646 wxPyEndAllowThreads(__tstate);
39647 if (PyErr_Occurred()) SWIG_fail;
39648 }
39649 {
39650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39651 }
39652 return resultobj;
39653 fail:
39654 return NULL;
39655 }
39656
39657
39658 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39659 PyObject *resultobj = 0;
39660 wxMenu *arg1 = (wxMenu *) 0 ;
39661 void *argp1 = 0 ;
39662 int res1 = 0 ;
39663 PyObject *swig_obj[1] ;
39664
39665 if (!args) SWIG_fail;
39666 swig_obj[0] = args;
39667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39668 if (!SWIG_IsOK(res1)) {
39669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39670 }
39671 arg1 = reinterpret_cast< wxMenu * >(argp1);
39672 {
39673 PyThreadState* __tstate = wxPyBeginAllowThreads();
39674 wxMenu_Destroy(arg1);
39675 wxPyEndAllowThreads(__tstate);
39676 if (PyErr_Occurred()) SWIG_fail;
39677 }
39678 resultobj = SWIG_Py_Void();
39679 return resultobj;
39680 fail:
39681 return NULL;
39682 }
39683
39684
39685 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39686 PyObject *resultobj = 0;
39687 wxMenu *arg1 = (wxMenu *) 0 ;
39688 int arg2 ;
39689 bool result;
39690 void *argp1 = 0 ;
39691 int res1 = 0 ;
39692 int val2 ;
39693 int ecode2 = 0 ;
39694 PyObject * obj0 = 0 ;
39695 PyObject * obj1 = 0 ;
39696 char * kwnames[] = {
39697 (char *) "self",(char *) "id", NULL
39698 };
39699
39700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39702 if (!SWIG_IsOK(res1)) {
39703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39704 }
39705 arg1 = reinterpret_cast< wxMenu * >(argp1);
39706 ecode2 = SWIG_AsVal_int(obj1, &val2);
39707 if (!SWIG_IsOK(ecode2)) {
39708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39709 }
39710 arg2 = static_cast< int >(val2);
39711 {
39712 PyThreadState* __tstate = wxPyBeginAllowThreads();
39713 result = (bool)(arg1)->Destroy(arg2);
39714 wxPyEndAllowThreads(__tstate);
39715 if (PyErr_Occurred()) SWIG_fail;
39716 }
39717 {
39718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39719 }
39720 return resultobj;
39721 fail:
39722 return NULL;
39723 }
39724
39725
39726 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39727 PyObject *resultobj = 0;
39728 wxMenu *arg1 = (wxMenu *) 0 ;
39729 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39730 bool result;
39731 void *argp1 = 0 ;
39732 int res1 = 0 ;
39733 void *argp2 = 0 ;
39734 int res2 = 0 ;
39735 PyObject * obj0 = 0 ;
39736 PyObject * obj1 = 0 ;
39737 char * kwnames[] = {
39738 (char *) "self",(char *) "item", NULL
39739 };
39740
39741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39743 if (!SWIG_IsOK(res1)) {
39744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39745 }
39746 arg1 = reinterpret_cast< wxMenu * >(argp1);
39747 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39748 if (!SWIG_IsOK(res2)) {
39749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39750 }
39751 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39752 {
39753 PyThreadState* __tstate = wxPyBeginAllowThreads();
39754 result = (bool)(arg1)->Destroy(arg2);
39755 wxPyEndAllowThreads(__tstate);
39756 if (PyErr_Occurred()) SWIG_fail;
39757 }
39758 {
39759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39760 }
39761 return resultobj;
39762 fail:
39763 return NULL;
39764 }
39765
39766
39767 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39768 PyObject *resultobj = 0;
39769 wxMenu *arg1 = (wxMenu *) 0 ;
39770 size_t result;
39771 void *argp1 = 0 ;
39772 int res1 = 0 ;
39773 PyObject *swig_obj[1] ;
39774
39775 if (!args) SWIG_fail;
39776 swig_obj[0] = args;
39777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39778 if (!SWIG_IsOK(res1)) {
39779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39780 }
39781 arg1 = reinterpret_cast< wxMenu * >(argp1);
39782 {
39783 PyThreadState* __tstate = wxPyBeginAllowThreads();
39784 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39785 wxPyEndAllowThreads(__tstate);
39786 if (PyErr_Occurred()) SWIG_fail;
39787 }
39788 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39789 return resultobj;
39790 fail:
39791 return NULL;
39792 }
39793
39794
39795 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39796 PyObject *resultobj = 0;
39797 wxMenu *arg1 = (wxMenu *) 0 ;
39798 PyObject *result = 0 ;
39799 void *argp1 = 0 ;
39800 int res1 = 0 ;
39801 PyObject *swig_obj[1] ;
39802
39803 if (!args) SWIG_fail;
39804 swig_obj[0] = args;
39805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39806 if (!SWIG_IsOK(res1)) {
39807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39808 }
39809 arg1 = reinterpret_cast< wxMenu * >(argp1);
39810 {
39811 PyThreadState* __tstate = wxPyBeginAllowThreads();
39812 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39813 wxPyEndAllowThreads(__tstate);
39814 if (PyErr_Occurred()) SWIG_fail;
39815 }
39816 resultobj = result;
39817 return resultobj;
39818 fail:
39819 return NULL;
39820 }
39821
39822
39823 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39824 PyObject *resultobj = 0;
39825 wxMenu *arg1 = (wxMenu *) 0 ;
39826 wxString *arg2 = 0 ;
39827 int result;
39828 void *argp1 = 0 ;
39829 int res1 = 0 ;
39830 bool temp2 = false ;
39831 PyObject * obj0 = 0 ;
39832 PyObject * obj1 = 0 ;
39833 char * kwnames[] = {
39834 (char *) "self",(char *) "item", NULL
39835 };
39836
39837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39839 if (!SWIG_IsOK(res1)) {
39840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39841 }
39842 arg1 = reinterpret_cast< wxMenu * >(argp1);
39843 {
39844 arg2 = wxString_in_helper(obj1);
39845 if (arg2 == NULL) SWIG_fail;
39846 temp2 = true;
39847 }
39848 {
39849 PyThreadState* __tstate = wxPyBeginAllowThreads();
39850 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39851 wxPyEndAllowThreads(__tstate);
39852 if (PyErr_Occurred()) SWIG_fail;
39853 }
39854 resultobj = SWIG_From_int(static_cast< int >(result));
39855 {
39856 if (temp2)
39857 delete arg2;
39858 }
39859 return resultobj;
39860 fail:
39861 {
39862 if (temp2)
39863 delete arg2;
39864 }
39865 return NULL;
39866 }
39867
39868
39869 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39870 PyObject *resultobj = 0;
39871 wxMenu *arg1 = (wxMenu *) 0 ;
39872 int arg2 ;
39873 wxMenuItem *result = 0 ;
39874 void *argp1 = 0 ;
39875 int res1 = 0 ;
39876 int val2 ;
39877 int ecode2 = 0 ;
39878 PyObject * obj0 = 0 ;
39879 PyObject * obj1 = 0 ;
39880 char * kwnames[] = {
39881 (char *) "self",(char *) "id", NULL
39882 };
39883
39884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39886 if (!SWIG_IsOK(res1)) {
39887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39888 }
39889 arg1 = reinterpret_cast< wxMenu * >(argp1);
39890 ecode2 = SWIG_AsVal_int(obj1, &val2);
39891 if (!SWIG_IsOK(ecode2)) {
39892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39893 }
39894 arg2 = static_cast< int >(val2);
39895 {
39896 PyThreadState* __tstate = wxPyBeginAllowThreads();
39897 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39898 wxPyEndAllowThreads(__tstate);
39899 if (PyErr_Occurred()) SWIG_fail;
39900 }
39901 {
39902 resultobj = wxPyMake_wxObject(result, (bool)0);
39903 }
39904 return resultobj;
39905 fail:
39906 return NULL;
39907 }
39908
39909
39910 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39911 PyObject *resultobj = 0;
39912 wxMenu *arg1 = (wxMenu *) 0 ;
39913 size_t arg2 ;
39914 wxMenuItem *result = 0 ;
39915 void *argp1 = 0 ;
39916 int res1 = 0 ;
39917 size_t val2 ;
39918 int ecode2 = 0 ;
39919 PyObject * obj0 = 0 ;
39920 PyObject * obj1 = 0 ;
39921 char * kwnames[] = {
39922 (char *) "self",(char *) "position", NULL
39923 };
39924
39925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39927 if (!SWIG_IsOK(res1)) {
39928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39929 }
39930 arg1 = reinterpret_cast< wxMenu * >(argp1);
39931 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39932 if (!SWIG_IsOK(ecode2)) {
39933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39934 }
39935 arg2 = static_cast< size_t >(val2);
39936 {
39937 PyThreadState* __tstate = wxPyBeginAllowThreads();
39938 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39939 wxPyEndAllowThreads(__tstate);
39940 if (PyErr_Occurred()) SWIG_fail;
39941 }
39942 {
39943 resultobj = wxPyMake_wxObject(result, (bool)0);
39944 }
39945 return resultobj;
39946 fail:
39947 return NULL;
39948 }
39949
39950
39951 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39952 PyObject *resultobj = 0;
39953 wxMenu *arg1 = (wxMenu *) 0 ;
39954 int arg2 ;
39955 bool arg3 ;
39956 void *argp1 = 0 ;
39957 int res1 = 0 ;
39958 int val2 ;
39959 int ecode2 = 0 ;
39960 bool val3 ;
39961 int ecode3 = 0 ;
39962 PyObject * obj0 = 0 ;
39963 PyObject * obj1 = 0 ;
39964 PyObject * obj2 = 0 ;
39965 char * kwnames[] = {
39966 (char *) "self",(char *) "id",(char *) "enable", NULL
39967 };
39968
39969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39971 if (!SWIG_IsOK(res1)) {
39972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39973 }
39974 arg1 = reinterpret_cast< wxMenu * >(argp1);
39975 ecode2 = SWIG_AsVal_int(obj1, &val2);
39976 if (!SWIG_IsOK(ecode2)) {
39977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39978 }
39979 arg2 = static_cast< int >(val2);
39980 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39981 if (!SWIG_IsOK(ecode3)) {
39982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39983 }
39984 arg3 = static_cast< bool >(val3);
39985 {
39986 PyThreadState* __tstate = wxPyBeginAllowThreads();
39987 (arg1)->Enable(arg2,arg3);
39988 wxPyEndAllowThreads(__tstate);
39989 if (PyErr_Occurred()) SWIG_fail;
39990 }
39991 resultobj = SWIG_Py_Void();
39992 return resultobj;
39993 fail:
39994 return NULL;
39995 }
39996
39997
39998 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39999 PyObject *resultobj = 0;
40000 wxMenu *arg1 = (wxMenu *) 0 ;
40001 int arg2 ;
40002 bool result;
40003 void *argp1 = 0 ;
40004 int res1 = 0 ;
40005 int val2 ;
40006 int ecode2 = 0 ;
40007 PyObject * obj0 = 0 ;
40008 PyObject * obj1 = 0 ;
40009 char * kwnames[] = {
40010 (char *) "self",(char *) "id", NULL
40011 };
40012
40013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40015 if (!SWIG_IsOK(res1)) {
40016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40017 }
40018 arg1 = reinterpret_cast< wxMenu * >(argp1);
40019 ecode2 = SWIG_AsVal_int(obj1, &val2);
40020 if (!SWIG_IsOK(ecode2)) {
40021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40022 }
40023 arg2 = static_cast< int >(val2);
40024 {
40025 PyThreadState* __tstate = wxPyBeginAllowThreads();
40026 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40027 wxPyEndAllowThreads(__tstate);
40028 if (PyErr_Occurred()) SWIG_fail;
40029 }
40030 {
40031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40032 }
40033 return resultobj;
40034 fail:
40035 return NULL;
40036 }
40037
40038
40039 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40040 PyObject *resultobj = 0;
40041 wxMenu *arg1 = (wxMenu *) 0 ;
40042 int arg2 ;
40043 bool arg3 ;
40044 void *argp1 = 0 ;
40045 int res1 = 0 ;
40046 int val2 ;
40047 int ecode2 = 0 ;
40048 bool val3 ;
40049 int ecode3 = 0 ;
40050 PyObject * obj0 = 0 ;
40051 PyObject * obj1 = 0 ;
40052 PyObject * obj2 = 0 ;
40053 char * kwnames[] = {
40054 (char *) "self",(char *) "id",(char *) "check", NULL
40055 };
40056
40057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40059 if (!SWIG_IsOK(res1)) {
40060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40061 }
40062 arg1 = reinterpret_cast< wxMenu * >(argp1);
40063 ecode2 = SWIG_AsVal_int(obj1, &val2);
40064 if (!SWIG_IsOK(ecode2)) {
40065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40066 }
40067 arg2 = static_cast< int >(val2);
40068 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40069 if (!SWIG_IsOK(ecode3)) {
40070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40071 }
40072 arg3 = static_cast< bool >(val3);
40073 {
40074 PyThreadState* __tstate = wxPyBeginAllowThreads();
40075 (arg1)->Check(arg2,arg3);
40076 wxPyEndAllowThreads(__tstate);
40077 if (PyErr_Occurred()) SWIG_fail;
40078 }
40079 resultobj = SWIG_Py_Void();
40080 return resultobj;
40081 fail:
40082 return NULL;
40083 }
40084
40085
40086 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40087 PyObject *resultobj = 0;
40088 wxMenu *arg1 = (wxMenu *) 0 ;
40089 int arg2 ;
40090 bool result;
40091 void *argp1 = 0 ;
40092 int res1 = 0 ;
40093 int val2 ;
40094 int ecode2 = 0 ;
40095 PyObject * obj0 = 0 ;
40096 PyObject * obj1 = 0 ;
40097 char * kwnames[] = {
40098 (char *) "self",(char *) "id", NULL
40099 };
40100
40101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40103 if (!SWIG_IsOK(res1)) {
40104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40105 }
40106 arg1 = reinterpret_cast< wxMenu * >(argp1);
40107 ecode2 = SWIG_AsVal_int(obj1, &val2);
40108 if (!SWIG_IsOK(ecode2)) {
40109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40110 }
40111 arg2 = static_cast< int >(val2);
40112 {
40113 PyThreadState* __tstate = wxPyBeginAllowThreads();
40114 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40115 wxPyEndAllowThreads(__tstate);
40116 if (PyErr_Occurred()) SWIG_fail;
40117 }
40118 {
40119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40120 }
40121 return resultobj;
40122 fail:
40123 return NULL;
40124 }
40125
40126
40127 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40128 PyObject *resultobj = 0;
40129 wxMenu *arg1 = (wxMenu *) 0 ;
40130 int arg2 ;
40131 wxString *arg3 = 0 ;
40132 void *argp1 = 0 ;
40133 int res1 = 0 ;
40134 int val2 ;
40135 int ecode2 = 0 ;
40136 bool temp3 = false ;
40137 PyObject * obj0 = 0 ;
40138 PyObject * obj1 = 0 ;
40139 PyObject * obj2 = 0 ;
40140 char * kwnames[] = {
40141 (char *) "self",(char *) "id",(char *) "label", NULL
40142 };
40143
40144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40146 if (!SWIG_IsOK(res1)) {
40147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40148 }
40149 arg1 = reinterpret_cast< wxMenu * >(argp1);
40150 ecode2 = SWIG_AsVal_int(obj1, &val2);
40151 if (!SWIG_IsOK(ecode2)) {
40152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40153 }
40154 arg2 = static_cast< int >(val2);
40155 {
40156 arg3 = wxString_in_helper(obj2);
40157 if (arg3 == NULL) SWIG_fail;
40158 temp3 = true;
40159 }
40160 {
40161 PyThreadState* __tstate = wxPyBeginAllowThreads();
40162 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40163 wxPyEndAllowThreads(__tstate);
40164 if (PyErr_Occurred()) SWIG_fail;
40165 }
40166 resultobj = SWIG_Py_Void();
40167 {
40168 if (temp3)
40169 delete arg3;
40170 }
40171 return resultobj;
40172 fail:
40173 {
40174 if (temp3)
40175 delete arg3;
40176 }
40177 return NULL;
40178 }
40179
40180
40181 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40182 PyObject *resultobj = 0;
40183 wxMenu *arg1 = (wxMenu *) 0 ;
40184 int arg2 ;
40185 wxString result;
40186 void *argp1 = 0 ;
40187 int res1 = 0 ;
40188 int val2 ;
40189 int ecode2 = 0 ;
40190 PyObject * obj0 = 0 ;
40191 PyObject * obj1 = 0 ;
40192 char * kwnames[] = {
40193 (char *) "self",(char *) "id", NULL
40194 };
40195
40196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40198 if (!SWIG_IsOK(res1)) {
40199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40200 }
40201 arg1 = reinterpret_cast< wxMenu * >(argp1);
40202 ecode2 = SWIG_AsVal_int(obj1, &val2);
40203 if (!SWIG_IsOK(ecode2)) {
40204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40205 }
40206 arg2 = static_cast< int >(val2);
40207 {
40208 PyThreadState* __tstate = wxPyBeginAllowThreads();
40209 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40210 wxPyEndAllowThreads(__tstate);
40211 if (PyErr_Occurred()) SWIG_fail;
40212 }
40213 {
40214 #if wxUSE_UNICODE
40215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40216 #else
40217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40218 #endif
40219 }
40220 return resultobj;
40221 fail:
40222 return NULL;
40223 }
40224
40225
40226 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40227 PyObject *resultobj = 0;
40228 wxMenu *arg1 = (wxMenu *) 0 ;
40229 int arg2 ;
40230 wxString *arg3 = 0 ;
40231 void *argp1 = 0 ;
40232 int res1 = 0 ;
40233 int val2 ;
40234 int ecode2 = 0 ;
40235 bool temp3 = false ;
40236 PyObject * obj0 = 0 ;
40237 PyObject * obj1 = 0 ;
40238 PyObject * obj2 = 0 ;
40239 char * kwnames[] = {
40240 (char *) "self",(char *) "id",(char *) "helpString", NULL
40241 };
40242
40243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40245 if (!SWIG_IsOK(res1)) {
40246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40247 }
40248 arg1 = reinterpret_cast< wxMenu * >(argp1);
40249 ecode2 = SWIG_AsVal_int(obj1, &val2);
40250 if (!SWIG_IsOK(ecode2)) {
40251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40252 }
40253 arg2 = static_cast< int >(val2);
40254 {
40255 arg3 = wxString_in_helper(obj2);
40256 if (arg3 == NULL) SWIG_fail;
40257 temp3 = true;
40258 }
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40262 wxPyEndAllowThreads(__tstate);
40263 if (PyErr_Occurred()) SWIG_fail;
40264 }
40265 resultobj = SWIG_Py_Void();
40266 {
40267 if (temp3)
40268 delete arg3;
40269 }
40270 return resultobj;
40271 fail:
40272 {
40273 if (temp3)
40274 delete arg3;
40275 }
40276 return NULL;
40277 }
40278
40279
40280 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40281 PyObject *resultobj = 0;
40282 wxMenu *arg1 = (wxMenu *) 0 ;
40283 int arg2 ;
40284 wxString result;
40285 void *argp1 = 0 ;
40286 int res1 = 0 ;
40287 int val2 ;
40288 int ecode2 = 0 ;
40289 PyObject * obj0 = 0 ;
40290 PyObject * obj1 = 0 ;
40291 char * kwnames[] = {
40292 (char *) "self",(char *) "id", NULL
40293 };
40294
40295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40297 if (!SWIG_IsOK(res1)) {
40298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40299 }
40300 arg1 = reinterpret_cast< wxMenu * >(argp1);
40301 ecode2 = SWIG_AsVal_int(obj1, &val2);
40302 if (!SWIG_IsOK(ecode2)) {
40303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40304 }
40305 arg2 = static_cast< int >(val2);
40306 {
40307 PyThreadState* __tstate = wxPyBeginAllowThreads();
40308 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40309 wxPyEndAllowThreads(__tstate);
40310 if (PyErr_Occurred()) SWIG_fail;
40311 }
40312 {
40313 #if wxUSE_UNICODE
40314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40315 #else
40316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40317 #endif
40318 }
40319 return resultobj;
40320 fail:
40321 return NULL;
40322 }
40323
40324
40325 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40326 PyObject *resultobj = 0;
40327 wxMenu *arg1 = (wxMenu *) 0 ;
40328 wxString *arg2 = 0 ;
40329 void *argp1 = 0 ;
40330 int res1 = 0 ;
40331 bool temp2 = false ;
40332 PyObject * obj0 = 0 ;
40333 PyObject * obj1 = 0 ;
40334 char * kwnames[] = {
40335 (char *) "self",(char *) "title", NULL
40336 };
40337
40338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40340 if (!SWIG_IsOK(res1)) {
40341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40342 }
40343 arg1 = reinterpret_cast< wxMenu * >(argp1);
40344 {
40345 arg2 = wxString_in_helper(obj1);
40346 if (arg2 == NULL) SWIG_fail;
40347 temp2 = true;
40348 }
40349 {
40350 PyThreadState* __tstate = wxPyBeginAllowThreads();
40351 (arg1)->SetTitle((wxString const &)*arg2);
40352 wxPyEndAllowThreads(__tstate);
40353 if (PyErr_Occurred()) SWIG_fail;
40354 }
40355 resultobj = SWIG_Py_Void();
40356 {
40357 if (temp2)
40358 delete arg2;
40359 }
40360 return resultobj;
40361 fail:
40362 {
40363 if (temp2)
40364 delete arg2;
40365 }
40366 return NULL;
40367 }
40368
40369
40370 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40371 PyObject *resultobj = 0;
40372 wxMenu *arg1 = (wxMenu *) 0 ;
40373 wxString result;
40374 void *argp1 = 0 ;
40375 int res1 = 0 ;
40376 PyObject *swig_obj[1] ;
40377
40378 if (!args) SWIG_fail;
40379 swig_obj[0] = args;
40380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40381 if (!SWIG_IsOK(res1)) {
40382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40383 }
40384 arg1 = reinterpret_cast< wxMenu * >(argp1);
40385 {
40386 PyThreadState* __tstate = wxPyBeginAllowThreads();
40387 result = ((wxMenu const *)arg1)->GetTitle();
40388 wxPyEndAllowThreads(__tstate);
40389 if (PyErr_Occurred()) SWIG_fail;
40390 }
40391 {
40392 #if wxUSE_UNICODE
40393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40394 #else
40395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40396 #endif
40397 }
40398 return resultobj;
40399 fail:
40400 return NULL;
40401 }
40402
40403
40404 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40405 PyObject *resultobj = 0;
40406 wxMenu *arg1 = (wxMenu *) 0 ;
40407 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40408 void *argp1 = 0 ;
40409 int res1 = 0 ;
40410 void *argp2 = 0 ;
40411 int res2 = 0 ;
40412 PyObject * obj0 = 0 ;
40413 PyObject * obj1 = 0 ;
40414 char * kwnames[] = {
40415 (char *) "self",(char *) "handler", NULL
40416 };
40417
40418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40420 if (!SWIG_IsOK(res1)) {
40421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40422 }
40423 arg1 = reinterpret_cast< wxMenu * >(argp1);
40424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40425 if (!SWIG_IsOK(res2)) {
40426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40427 }
40428 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40429 {
40430 PyThreadState* __tstate = wxPyBeginAllowThreads();
40431 (arg1)->SetEventHandler(arg2);
40432 wxPyEndAllowThreads(__tstate);
40433 if (PyErr_Occurred()) SWIG_fail;
40434 }
40435 resultobj = SWIG_Py_Void();
40436 return resultobj;
40437 fail:
40438 return NULL;
40439 }
40440
40441
40442 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40443 PyObject *resultobj = 0;
40444 wxMenu *arg1 = (wxMenu *) 0 ;
40445 wxEvtHandler *result = 0 ;
40446 void *argp1 = 0 ;
40447 int res1 = 0 ;
40448 PyObject *swig_obj[1] ;
40449
40450 if (!args) SWIG_fail;
40451 swig_obj[0] = args;
40452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40453 if (!SWIG_IsOK(res1)) {
40454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40455 }
40456 arg1 = reinterpret_cast< wxMenu * >(argp1);
40457 {
40458 PyThreadState* __tstate = wxPyBeginAllowThreads();
40459 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40460 wxPyEndAllowThreads(__tstate);
40461 if (PyErr_Occurred()) SWIG_fail;
40462 }
40463 {
40464 resultobj = wxPyMake_wxObject(result, 0);
40465 }
40466 return resultobj;
40467 fail:
40468 return NULL;
40469 }
40470
40471
40472 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40473 PyObject *resultobj = 0;
40474 wxMenu *arg1 = (wxMenu *) 0 ;
40475 wxWindow *arg2 = (wxWindow *) 0 ;
40476 void *argp1 = 0 ;
40477 int res1 = 0 ;
40478 void *argp2 = 0 ;
40479 int res2 = 0 ;
40480 PyObject * obj0 = 0 ;
40481 PyObject * obj1 = 0 ;
40482 char * kwnames[] = {
40483 (char *) "self",(char *) "win", NULL
40484 };
40485
40486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40488 if (!SWIG_IsOK(res1)) {
40489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40490 }
40491 arg1 = reinterpret_cast< wxMenu * >(argp1);
40492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40493 if (!SWIG_IsOK(res2)) {
40494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40495 }
40496 arg2 = reinterpret_cast< wxWindow * >(argp2);
40497 {
40498 PyThreadState* __tstate = wxPyBeginAllowThreads();
40499 (arg1)->SetInvokingWindow(arg2);
40500 wxPyEndAllowThreads(__tstate);
40501 if (PyErr_Occurred()) SWIG_fail;
40502 }
40503 resultobj = SWIG_Py_Void();
40504 return resultobj;
40505 fail:
40506 return NULL;
40507 }
40508
40509
40510 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40511 PyObject *resultobj = 0;
40512 wxMenu *arg1 = (wxMenu *) 0 ;
40513 wxWindow *result = 0 ;
40514 void *argp1 = 0 ;
40515 int res1 = 0 ;
40516 PyObject *swig_obj[1] ;
40517
40518 if (!args) SWIG_fail;
40519 swig_obj[0] = args;
40520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40521 if (!SWIG_IsOK(res1)) {
40522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40523 }
40524 arg1 = reinterpret_cast< wxMenu * >(argp1);
40525 {
40526 PyThreadState* __tstate = wxPyBeginAllowThreads();
40527 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40528 wxPyEndAllowThreads(__tstate);
40529 if (PyErr_Occurred()) SWIG_fail;
40530 }
40531 {
40532 resultobj = wxPyMake_wxObject(result, 0);
40533 }
40534 return resultobj;
40535 fail:
40536 return NULL;
40537 }
40538
40539
40540 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40541 PyObject *resultobj = 0;
40542 wxMenu *arg1 = (wxMenu *) 0 ;
40543 long result;
40544 void *argp1 = 0 ;
40545 int res1 = 0 ;
40546 PyObject *swig_obj[1] ;
40547
40548 if (!args) SWIG_fail;
40549 swig_obj[0] = args;
40550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40551 if (!SWIG_IsOK(res1)) {
40552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40553 }
40554 arg1 = reinterpret_cast< wxMenu * >(argp1);
40555 {
40556 PyThreadState* __tstate = wxPyBeginAllowThreads();
40557 result = (long)((wxMenu const *)arg1)->GetStyle();
40558 wxPyEndAllowThreads(__tstate);
40559 if (PyErr_Occurred()) SWIG_fail;
40560 }
40561 resultobj = SWIG_From_long(static_cast< long >(result));
40562 return resultobj;
40563 fail:
40564 return NULL;
40565 }
40566
40567
40568 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40569 PyObject *resultobj = 0;
40570 wxMenu *arg1 = (wxMenu *) 0 ;
40571 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40572 void *argp1 = 0 ;
40573 int res1 = 0 ;
40574 void *argp2 = 0 ;
40575 int res2 = 0 ;
40576 PyObject * obj0 = 0 ;
40577 PyObject * obj1 = 0 ;
40578 char * kwnames[] = {
40579 (char *) "self",(char *) "source", NULL
40580 };
40581
40582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40584 if (!SWIG_IsOK(res1)) {
40585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40586 }
40587 arg1 = reinterpret_cast< wxMenu * >(argp1);
40588 if (obj1) {
40589 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40590 if (!SWIG_IsOK(res2)) {
40591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40592 }
40593 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40594 }
40595 {
40596 PyThreadState* __tstate = wxPyBeginAllowThreads();
40597 (arg1)->UpdateUI(arg2);
40598 wxPyEndAllowThreads(__tstate);
40599 if (PyErr_Occurred()) SWIG_fail;
40600 }
40601 resultobj = SWIG_Py_Void();
40602 return resultobj;
40603 fail:
40604 return NULL;
40605 }
40606
40607
40608 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40609 PyObject *resultobj = 0;
40610 wxMenu *arg1 = (wxMenu *) 0 ;
40611 wxMenuBar *result = 0 ;
40612 void *argp1 = 0 ;
40613 int res1 = 0 ;
40614 PyObject *swig_obj[1] ;
40615
40616 if (!args) SWIG_fail;
40617 swig_obj[0] = args;
40618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40619 if (!SWIG_IsOK(res1)) {
40620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40621 }
40622 arg1 = reinterpret_cast< wxMenu * >(argp1);
40623 {
40624 PyThreadState* __tstate = wxPyBeginAllowThreads();
40625 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40626 wxPyEndAllowThreads(__tstate);
40627 if (PyErr_Occurred()) SWIG_fail;
40628 }
40629 {
40630 resultobj = wxPyMake_wxObject(result, (bool)0);
40631 }
40632 return resultobj;
40633 fail:
40634 return NULL;
40635 }
40636
40637
40638 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40639 PyObject *resultobj = 0;
40640 wxMenu *arg1 = (wxMenu *) 0 ;
40641 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40642 void *argp1 = 0 ;
40643 int res1 = 0 ;
40644 void *argp2 = 0 ;
40645 int res2 = 0 ;
40646 PyObject * obj0 = 0 ;
40647 PyObject * obj1 = 0 ;
40648 char * kwnames[] = {
40649 (char *) "self",(char *) "menubar", NULL
40650 };
40651
40652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40654 if (!SWIG_IsOK(res1)) {
40655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40656 }
40657 arg1 = reinterpret_cast< wxMenu * >(argp1);
40658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40659 if (!SWIG_IsOK(res2)) {
40660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40661 }
40662 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40663 {
40664 PyThreadState* __tstate = wxPyBeginAllowThreads();
40665 (arg1)->Attach(arg2);
40666 wxPyEndAllowThreads(__tstate);
40667 if (PyErr_Occurred()) SWIG_fail;
40668 }
40669 resultobj = SWIG_Py_Void();
40670 return resultobj;
40671 fail:
40672 return NULL;
40673 }
40674
40675
40676 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40677 PyObject *resultobj = 0;
40678 wxMenu *arg1 = (wxMenu *) 0 ;
40679 void *argp1 = 0 ;
40680 int res1 = 0 ;
40681 PyObject *swig_obj[1] ;
40682
40683 if (!args) SWIG_fail;
40684 swig_obj[0] = args;
40685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40686 if (!SWIG_IsOK(res1)) {
40687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40688 }
40689 arg1 = reinterpret_cast< wxMenu * >(argp1);
40690 {
40691 PyThreadState* __tstate = wxPyBeginAllowThreads();
40692 (arg1)->Detach();
40693 wxPyEndAllowThreads(__tstate);
40694 if (PyErr_Occurred()) SWIG_fail;
40695 }
40696 resultobj = SWIG_Py_Void();
40697 return resultobj;
40698 fail:
40699 return NULL;
40700 }
40701
40702
40703 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40704 PyObject *resultobj = 0;
40705 wxMenu *arg1 = (wxMenu *) 0 ;
40706 bool result;
40707 void *argp1 = 0 ;
40708 int res1 = 0 ;
40709 PyObject *swig_obj[1] ;
40710
40711 if (!args) SWIG_fail;
40712 swig_obj[0] = args;
40713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40714 if (!SWIG_IsOK(res1)) {
40715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40716 }
40717 arg1 = reinterpret_cast< wxMenu * >(argp1);
40718 {
40719 PyThreadState* __tstate = wxPyBeginAllowThreads();
40720 result = (bool)((wxMenu const *)arg1)->IsAttached();
40721 wxPyEndAllowThreads(__tstate);
40722 if (PyErr_Occurred()) SWIG_fail;
40723 }
40724 {
40725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40726 }
40727 return resultobj;
40728 fail:
40729 return NULL;
40730 }
40731
40732
40733 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40734 PyObject *resultobj = 0;
40735 wxMenu *arg1 = (wxMenu *) 0 ;
40736 wxMenu *arg2 = (wxMenu *) 0 ;
40737 void *argp1 = 0 ;
40738 int res1 = 0 ;
40739 void *argp2 = 0 ;
40740 int res2 = 0 ;
40741 PyObject * obj0 = 0 ;
40742 PyObject * obj1 = 0 ;
40743 char * kwnames[] = {
40744 (char *) "self",(char *) "parent", NULL
40745 };
40746
40747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40749 if (!SWIG_IsOK(res1)) {
40750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40751 }
40752 arg1 = reinterpret_cast< wxMenu * >(argp1);
40753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40754 if (!SWIG_IsOK(res2)) {
40755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40756 }
40757 arg2 = reinterpret_cast< wxMenu * >(argp2);
40758 {
40759 PyThreadState* __tstate = wxPyBeginAllowThreads();
40760 (arg1)->SetParent(arg2);
40761 wxPyEndAllowThreads(__tstate);
40762 if (PyErr_Occurred()) SWIG_fail;
40763 }
40764 resultobj = SWIG_Py_Void();
40765 return resultobj;
40766 fail:
40767 return NULL;
40768 }
40769
40770
40771 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40772 PyObject *resultobj = 0;
40773 wxMenu *arg1 = (wxMenu *) 0 ;
40774 wxMenu *result = 0 ;
40775 void *argp1 = 0 ;
40776 int res1 = 0 ;
40777 PyObject *swig_obj[1] ;
40778
40779 if (!args) SWIG_fail;
40780 swig_obj[0] = args;
40781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40782 if (!SWIG_IsOK(res1)) {
40783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40784 }
40785 arg1 = reinterpret_cast< wxMenu * >(argp1);
40786 {
40787 PyThreadState* __tstate = wxPyBeginAllowThreads();
40788 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40789 wxPyEndAllowThreads(__tstate);
40790 if (PyErr_Occurred()) SWIG_fail;
40791 }
40792 {
40793 resultobj = wxPyMake_wxObject(result, 0);
40794 }
40795 return resultobj;
40796 fail:
40797 return NULL;
40798 }
40799
40800
40801 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40802 PyObject *obj;
40803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40804 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40805 return SWIG_Py_Void();
40806 }
40807
40808 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40809 return SWIG_Python_InitShadowInstance(args);
40810 }
40811
40812 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40813 PyObject *resultobj = 0;
40814 long arg1 = (long) 0 ;
40815 wxMenuBar *result = 0 ;
40816 long val1 ;
40817 int ecode1 = 0 ;
40818 PyObject * obj0 = 0 ;
40819 char * kwnames[] = {
40820 (char *) "style", NULL
40821 };
40822
40823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40824 if (obj0) {
40825 ecode1 = SWIG_AsVal_long(obj0, &val1);
40826 if (!SWIG_IsOK(ecode1)) {
40827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40828 }
40829 arg1 = static_cast< long >(val1);
40830 }
40831 {
40832 if (!wxPyCheckForApp()) SWIG_fail;
40833 PyThreadState* __tstate = wxPyBeginAllowThreads();
40834 result = (wxMenuBar *)new wxMenuBar(arg1);
40835 wxPyEndAllowThreads(__tstate);
40836 if (PyErr_Occurred()) SWIG_fail;
40837 }
40838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40839 return resultobj;
40840 fail:
40841 return NULL;
40842 }
40843
40844
40845 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40846 PyObject *resultobj = 0;
40847 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40848 wxMenu *arg2 = (wxMenu *) 0 ;
40849 wxString *arg3 = 0 ;
40850 bool result;
40851 void *argp1 = 0 ;
40852 int res1 = 0 ;
40853 void *argp2 = 0 ;
40854 int res2 = 0 ;
40855 bool temp3 = false ;
40856 PyObject * obj0 = 0 ;
40857 PyObject * obj1 = 0 ;
40858 PyObject * obj2 = 0 ;
40859 char * kwnames[] = {
40860 (char *) "self",(char *) "menu",(char *) "title", NULL
40861 };
40862
40863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40865 if (!SWIG_IsOK(res1)) {
40866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40867 }
40868 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40869 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40870 if (!SWIG_IsOK(res2)) {
40871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40872 }
40873 arg2 = reinterpret_cast< wxMenu * >(argp2);
40874 {
40875 arg3 = wxString_in_helper(obj2);
40876 if (arg3 == NULL) SWIG_fail;
40877 temp3 = true;
40878 }
40879 {
40880 PyThreadState* __tstate = wxPyBeginAllowThreads();
40881 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40882 wxPyEndAllowThreads(__tstate);
40883 if (PyErr_Occurred()) SWIG_fail;
40884 }
40885 {
40886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40887 }
40888 {
40889 if (temp3)
40890 delete arg3;
40891 }
40892 return resultobj;
40893 fail:
40894 {
40895 if (temp3)
40896 delete arg3;
40897 }
40898 return NULL;
40899 }
40900
40901
40902 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40903 PyObject *resultobj = 0;
40904 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40905 size_t arg2 ;
40906 wxMenu *arg3 = (wxMenu *) 0 ;
40907 wxString *arg4 = 0 ;
40908 bool result;
40909 void *argp1 = 0 ;
40910 int res1 = 0 ;
40911 size_t val2 ;
40912 int ecode2 = 0 ;
40913 void *argp3 = 0 ;
40914 int res3 = 0 ;
40915 bool temp4 = false ;
40916 PyObject * obj0 = 0 ;
40917 PyObject * obj1 = 0 ;
40918 PyObject * obj2 = 0 ;
40919 PyObject * obj3 = 0 ;
40920 char * kwnames[] = {
40921 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40922 };
40923
40924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40926 if (!SWIG_IsOK(res1)) {
40927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40928 }
40929 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40930 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40931 if (!SWIG_IsOK(ecode2)) {
40932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40933 }
40934 arg2 = static_cast< size_t >(val2);
40935 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40936 if (!SWIG_IsOK(res3)) {
40937 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40938 }
40939 arg3 = reinterpret_cast< wxMenu * >(argp3);
40940 {
40941 arg4 = wxString_in_helper(obj3);
40942 if (arg4 == NULL) SWIG_fail;
40943 temp4 = true;
40944 }
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 {
40952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40953 }
40954 {
40955 if (temp4)
40956 delete arg4;
40957 }
40958 return resultobj;
40959 fail:
40960 {
40961 if (temp4)
40962 delete arg4;
40963 }
40964 return NULL;
40965 }
40966
40967
40968 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40969 PyObject *resultobj = 0;
40970 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40971 size_t result;
40972 void *argp1 = 0 ;
40973 int res1 = 0 ;
40974 PyObject *swig_obj[1] ;
40975
40976 if (!args) SWIG_fail;
40977 swig_obj[0] = args;
40978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40979 if (!SWIG_IsOK(res1)) {
40980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40981 }
40982 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40983 {
40984 PyThreadState* __tstate = wxPyBeginAllowThreads();
40985 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40986 wxPyEndAllowThreads(__tstate);
40987 if (PyErr_Occurred()) SWIG_fail;
40988 }
40989 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40990 return resultobj;
40991 fail:
40992 return NULL;
40993 }
40994
40995
40996 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40997 PyObject *resultobj = 0;
40998 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40999 size_t arg2 ;
41000 wxMenu *result = 0 ;
41001 void *argp1 = 0 ;
41002 int res1 = 0 ;
41003 size_t val2 ;
41004 int ecode2 = 0 ;
41005 PyObject * obj0 = 0 ;
41006 PyObject * obj1 = 0 ;
41007 char * kwnames[] = {
41008 (char *) "self",(char *) "pos", NULL
41009 };
41010
41011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41013 if (!SWIG_IsOK(res1)) {
41014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41015 }
41016 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41017 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41018 if (!SWIG_IsOK(ecode2)) {
41019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41020 }
41021 arg2 = static_cast< size_t >(val2);
41022 {
41023 PyThreadState* __tstate = wxPyBeginAllowThreads();
41024 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41025 wxPyEndAllowThreads(__tstate);
41026 if (PyErr_Occurred()) SWIG_fail;
41027 }
41028 {
41029 resultobj = wxPyMake_wxObject(result, 0);
41030 }
41031 return resultobj;
41032 fail:
41033 return NULL;
41034 }
41035
41036
41037 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41038 PyObject *resultobj = 0;
41039 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41040 size_t arg2 ;
41041 wxMenu *arg3 = (wxMenu *) 0 ;
41042 wxString *arg4 = 0 ;
41043 wxMenu *result = 0 ;
41044 void *argp1 = 0 ;
41045 int res1 = 0 ;
41046 size_t val2 ;
41047 int ecode2 = 0 ;
41048 void *argp3 = 0 ;
41049 int res3 = 0 ;
41050 bool temp4 = false ;
41051 PyObject * obj0 = 0 ;
41052 PyObject * obj1 = 0 ;
41053 PyObject * obj2 = 0 ;
41054 PyObject * obj3 = 0 ;
41055 char * kwnames[] = {
41056 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41057 };
41058
41059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41061 if (!SWIG_IsOK(res1)) {
41062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41063 }
41064 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41065 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41066 if (!SWIG_IsOK(ecode2)) {
41067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41068 }
41069 arg2 = static_cast< size_t >(val2);
41070 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41071 if (!SWIG_IsOK(res3)) {
41072 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41073 }
41074 arg3 = reinterpret_cast< wxMenu * >(argp3);
41075 {
41076 arg4 = wxString_in_helper(obj3);
41077 if (arg4 == NULL) SWIG_fail;
41078 temp4 = true;
41079 }
41080 {
41081 PyThreadState* __tstate = wxPyBeginAllowThreads();
41082 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41083 wxPyEndAllowThreads(__tstate);
41084 if (PyErr_Occurred()) SWIG_fail;
41085 }
41086 {
41087 resultobj = wxPyMake_wxObject(result, 0);
41088 }
41089 {
41090 if (temp4)
41091 delete arg4;
41092 }
41093 return resultobj;
41094 fail:
41095 {
41096 if (temp4)
41097 delete arg4;
41098 }
41099 return NULL;
41100 }
41101
41102
41103 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41104 PyObject *resultobj = 0;
41105 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41106 size_t arg2 ;
41107 wxMenu *result = 0 ;
41108 void *argp1 = 0 ;
41109 int res1 = 0 ;
41110 size_t val2 ;
41111 int ecode2 = 0 ;
41112 PyObject * obj0 = 0 ;
41113 PyObject * obj1 = 0 ;
41114 char * kwnames[] = {
41115 (char *) "self",(char *) "pos", NULL
41116 };
41117
41118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41120 if (!SWIG_IsOK(res1)) {
41121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41122 }
41123 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41124 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41125 if (!SWIG_IsOK(ecode2)) {
41126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41127 }
41128 arg2 = static_cast< size_t >(val2);
41129 {
41130 PyThreadState* __tstate = wxPyBeginAllowThreads();
41131 result = (wxMenu *)(arg1)->Remove(arg2);
41132 wxPyEndAllowThreads(__tstate);
41133 if (PyErr_Occurred()) SWIG_fail;
41134 }
41135 {
41136 resultobj = wxPyMake_wxObject(result, 0);
41137 }
41138 return resultobj;
41139 fail:
41140 return NULL;
41141 }
41142
41143
41144 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41145 PyObject *resultobj = 0;
41146 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41147 size_t arg2 ;
41148 bool arg3 ;
41149 void *argp1 = 0 ;
41150 int res1 = 0 ;
41151 size_t val2 ;
41152 int ecode2 = 0 ;
41153 bool val3 ;
41154 int ecode3 = 0 ;
41155 PyObject * obj0 = 0 ;
41156 PyObject * obj1 = 0 ;
41157 PyObject * obj2 = 0 ;
41158 char * kwnames[] = {
41159 (char *) "self",(char *) "pos",(char *) "enable", NULL
41160 };
41161
41162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41164 if (!SWIG_IsOK(res1)) {
41165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41166 }
41167 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41168 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41169 if (!SWIG_IsOK(ecode2)) {
41170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41171 }
41172 arg2 = static_cast< size_t >(val2);
41173 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41174 if (!SWIG_IsOK(ecode3)) {
41175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41176 }
41177 arg3 = static_cast< bool >(val3);
41178 {
41179 PyThreadState* __tstate = wxPyBeginAllowThreads();
41180 (arg1)->EnableTop(arg2,arg3);
41181 wxPyEndAllowThreads(__tstate);
41182 if (PyErr_Occurred()) SWIG_fail;
41183 }
41184 resultobj = SWIG_Py_Void();
41185 return resultobj;
41186 fail:
41187 return NULL;
41188 }
41189
41190
41191 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41192 PyObject *resultobj = 0;
41193 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41194 size_t arg2 ;
41195 bool result;
41196 void *argp1 = 0 ;
41197 int res1 = 0 ;
41198 size_t val2 ;
41199 int ecode2 = 0 ;
41200 PyObject * obj0 = 0 ;
41201 PyObject * obj1 = 0 ;
41202 char * kwnames[] = {
41203 (char *) "self",(char *) "pos", NULL
41204 };
41205
41206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41208 if (!SWIG_IsOK(res1)) {
41209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41210 }
41211 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41212 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41213 if (!SWIG_IsOK(ecode2)) {
41214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41215 }
41216 arg2 = static_cast< size_t >(val2);
41217 {
41218 PyThreadState* __tstate = wxPyBeginAllowThreads();
41219 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41220 wxPyEndAllowThreads(__tstate);
41221 if (PyErr_Occurred()) SWIG_fail;
41222 }
41223 {
41224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41225 }
41226 return resultobj;
41227 fail:
41228 return NULL;
41229 }
41230
41231
41232 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41233 PyObject *resultobj = 0;
41234 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41235 size_t arg2 ;
41236 wxString *arg3 = 0 ;
41237 void *argp1 = 0 ;
41238 int res1 = 0 ;
41239 size_t val2 ;
41240 int ecode2 = 0 ;
41241 bool temp3 = false ;
41242 PyObject * obj0 = 0 ;
41243 PyObject * obj1 = 0 ;
41244 PyObject * obj2 = 0 ;
41245 char * kwnames[] = {
41246 (char *) "self",(char *) "pos",(char *) "label", NULL
41247 };
41248
41249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41251 if (!SWIG_IsOK(res1)) {
41252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41253 }
41254 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41255 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41256 if (!SWIG_IsOK(ecode2)) {
41257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41258 }
41259 arg2 = static_cast< size_t >(val2);
41260 {
41261 arg3 = wxString_in_helper(obj2);
41262 if (arg3 == NULL) SWIG_fail;
41263 temp3 = true;
41264 }
41265 {
41266 PyThreadState* __tstate = wxPyBeginAllowThreads();
41267 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41268 wxPyEndAllowThreads(__tstate);
41269 if (PyErr_Occurred()) SWIG_fail;
41270 }
41271 resultobj = SWIG_Py_Void();
41272 {
41273 if (temp3)
41274 delete arg3;
41275 }
41276 return resultobj;
41277 fail:
41278 {
41279 if (temp3)
41280 delete arg3;
41281 }
41282 return NULL;
41283 }
41284
41285
41286 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41287 PyObject *resultobj = 0;
41288 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41289 size_t arg2 ;
41290 wxString result;
41291 void *argp1 = 0 ;
41292 int res1 = 0 ;
41293 size_t val2 ;
41294 int ecode2 = 0 ;
41295 PyObject * obj0 = 0 ;
41296 PyObject * obj1 = 0 ;
41297 char * kwnames[] = {
41298 (char *) "self",(char *) "pos", NULL
41299 };
41300
41301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41303 if (!SWIG_IsOK(res1)) {
41304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41305 }
41306 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41307 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41308 if (!SWIG_IsOK(ecode2)) {
41309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41310 }
41311 arg2 = static_cast< size_t >(val2);
41312 {
41313 PyThreadState* __tstate = wxPyBeginAllowThreads();
41314 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41315 wxPyEndAllowThreads(__tstate);
41316 if (PyErr_Occurred()) SWIG_fail;
41317 }
41318 {
41319 #if wxUSE_UNICODE
41320 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41321 #else
41322 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41323 #endif
41324 }
41325 return resultobj;
41326 fail:
41327 return NULL;
41328 }
41329
41330
41331 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41332 PyObject *resultobj = 0;
41333 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41334 wxString *arg2 = 0 ;
41335 wxString *arg3 = 0 ;
41336 int result;
41337 void *argp1 = 0 ;
41338 int res1 = 0 ;
41339 bool temp2 = false ;
41340 bool temp3 = false ;
41341 PyObject * obj0 = 0 ;
41342 PyObject * obj1 = 0 ;
41343 PyObject * obj2 = 0 ;
41344 char * kwnames[] = {
41345 (char *) "self",(char *) "menu",(char *) "item", NULL
41346 };
41347
41348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41350 if (!SWIG_IsOK(res1)) {
41351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41352 }
41353 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41354 {
41355 arg2 = wxString_in_helper(obj1);
41356 if (arg2 == NULL) SWIG_fail;
41357 temp2 = true;
41358 }
41359 {
41360 arg3 = wxString_in_helper(obj2);
41361 if (arg3 == NULL) SWIG_fail;
41362 temp3 = true;
41363 }
41364 {
41365 PyThreadState* __tstate = wxPyBeginAllowThreads();
41366 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41367 wxPyEndAllowThreads(__tstate);
41368 if (PyErr_Occurred()) SWIG_fail;
41369 }
41370 resultobj = SWIG_From_int(static_cast< int >(result));
41371 {
41372 if (temp2)
41373 delete arg2;
41374 }
41375 {
41376 if (temp3)
41377 delete arg3;
41378 }
41379 return resultobj;
41380 fail:
41381 {
41382 if (temp2)
41383 delete arg2;
41384 }
41385 {
41386 if (temp3)
41387 delete arg3;
41388 }
41389 return NULL;
41390 }
41391
41392
41393 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj = 0;
41395 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41396 int arg2 ;
41397 wxMenuItem *result = 0 ;
41398 void *argp1 = 0 ;
41399 int res1 = 0 ;
41400 int val2 ;
41401 int ecode2 = 0 ;
41402 PyObject * obj0 = 0 ;
41403 PyObject * obj1 = 0 ;
41404 char * kwnames[] = {
41405 (char *) "self",(char *) "id", NULL
41406 };
41407
41408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41410 if (!SWIG_IsOK(res1)) {
41411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41412 }
41413 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41414 ecode2 = SWIG_AsVal_int(obj1, &val2);
41415 if (!SWIG_IsOK(ecode2)) {
41416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41417 }
41418 arg2 = static_cast< int >(val2);
41419 {
41420 PyThreadState* __tstate = wxPyBeginAllowThreads();
41421 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41422 wxPyEndAllowThreads(__tstate);
41423 if (PyErr_Occurred()) SWIG_fail;
41424 }
41425 {
41426 resultobj = wxPyMake_wxObject(result, (bool)0);
41427 }
41428 return resultobj;
41429 fail:
41430 return NULL;
41431 }
41432
41433
41434 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41435 PyObject *resultobj = 0;
41436 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41437 wxString *arg2 = 0 ;
41438 int result;
41439 void *argp1 = 0 ;
41440 int res1 = 0 ;
41441 bool temp2 = false ;
41442 PyObject * obj0 = 0 ;
41443 PyObject * obj1 = 0 ;
41444 char * kwnames[] = {
41445 (char *) "self",(char *) "title", NULL
41446 };
41447
41448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41450 if (!SWIG_IsOK(res1)) {
41451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41452 }
41453 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41454 {
41455 arg2 = wxString_in_helper(obj1);
41456 if (arg2 == NULL) SWIG_fail;
41457 temp2 = true;
41458 }
41459 {
41460 PyThreadState* __tstate = wxPyBeginAllowThreads();
41461 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41462 wxPyEndAllowThreads(__tstate);
41463 if (PyErr_Occurred()) SWIG_fail;
41464 }
41465 resultobj = SWIG_From_int(static_cast< int >(result));
41466 {
41467 if (temp2)
41468 delete arg2;
41469 }
41470 return resultobj;
41471 fail:
41472 {
41473 if (temp2)
41474 delete arg2;
41475 }
41476 return NULL;
41477 }
41478
41479
41480 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41481 PyObject *resultobj = 0;
41482 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41483 int arg2 ;
41484 bool arg3 ;
41485 void *argp1 = 0 ;
41486 int res1 = 0 ;
41487 int val2 ;
41488 int ecode2 = 0 ;
41489 bool val3 ;
41490 int ecode3 = 0 ;
41491 PyObject * obj0 = 0 ;
41492 PyObject * obj1 = 0 ;
41493 PyObject * obj2 = 0 ;
41494 char * kwnames[] = {
41495 (char *) "self",(char *) "id",(char *) "enable", NULL
41496 };
41497
41498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41500 if (!SWIG_IsOK(res1)) {
41501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41502 }
41503 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41504 ecode2 = SWIG_AsVal_int(obj1, &val2);
41505 if (!SWIG_IsOK(ecode2)) {
41506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41507 }
41508 arg2 = static_cast< int >(val2);
41509 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41510 if (!SWIG_IsOK(ecode3)) {
41511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41512 }
41513 arg3 = static_cast< bool >(val3);
41514 {
41515 PyThreadState* __tstate = wxPyBeginAllowThreads();
41516 (arg1)->Enable(arg2,arg3);
41517 wxPyEndAllowThreads(__tstate);
41518 if (PyErr_Occurred()) SWIG_fail;
41519 }
41520 resultobj = SWIG_Py_Void();
41521 return resultobj;
41522 fail:
41523 return NULL;
41524 }
41525
41526
41527 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41528 PyObject *resultobj = 0;
41529 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41530 int arg2 ;
41531 bool arg3 ;
41532 void *argp1 = 0 ;
41533 int res1 = 0 ;
41534 int val2 ;
41535 int ecode2 = 0 ;
41536 bool val3 ;
41537 int ecode3 = 0 ;
41538 PyObject * obj0 = 0 ;
41539 PyObject * obj1 = 0 ;
41540 PyObject * obj2 = 0 ;
41541 char * kwnames[] = {
41542 (char *) "self",(char *) "id",(char *) "check", NULL
41543 };
41544
41545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41547 if (!SWIG_IsOK(res1)) {
41548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41549 }
41550 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41551 ecode2 = SWIG_AsVal_int(obj1, &val2);
41552 if (!SWIG_IsOK(ecode2)) {
41553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41554 }
41555 arg2 = static_cast< int >(val2);
41556 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41557 if (!SWIG_IsOK(ecode3)) {
41558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41559 }
41560 arg3 = static_cast< bool >(val3);
41561 {
41562 PyThreadState* __tstate = wxPyBeginAllowThreads();
41563 (arg1)->Check(arg2,arg3);
41564 wxPyEndAllowThreads(__tstate);
41565 if (PyErr_Occurred()) SWIG_fail;
41566 }
41567 resultobj = SWIG_Py_Void();
41568 return resultobj;
41569 fail:
41570 return NULL;
41571 }
41572
41573
41574 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41575 PyObject *resultobj = 0;
41576 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41577 int arg2 ;
41578 bool result;
41579 void *argp1 = 0 ;
41580 int res1 = 0 ;
41581 int val2 ;
41582 int ecode2 = 0 ;
41583 PyObject * obj0 = 0 ;
41584 PyObject * obj1 = 0 ;
41585 char * kwnames[] = {
41586 (char *) "self",(char *) "id", NULL
41587 };
41588
41589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41591 if (!SWIG_IsOK(res1)) {
41592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41593 }
41594 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41595 ecode2 = SWIG_AsVal_int(obj1, &val2);
41596 if (!SWIG_IsOK(ecode2)) {
41597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41598 }
41599 arg2 = static_cast< int >(val2);
41600 {
41601 PyThreadState* __tstate = wxPyBeginAllowThreads();
41602 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41603 wxPyEndAllowThreads(__tstate);
41604 if (PyErr_Occurred()) SWIG_fail;
41605 }
41606 {
41607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41608 }
41609 return resultobj;
41610 fail:
41611 return NULL;
41612 }
41613
41614
41615 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41616 PyObject *resultobj = 0;
41617 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41618 int arg2 ;
41619 bool result;
41620 void *argp1 = 0 ;
41621 int res1 = 0 ;
41622 int val2 ;
41623 int ecode2 = 0 ;
41624 PyObject * obj0 = 0 ;
41625 PyObject * obj1 = 0 ;
41626 char * kwnames[] = {
41627 (char *) "self",(char *) "id", NULL
41628 };
41629
41630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41632 if (!SWIG_IsOK(res1)) {
41633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41634 }
41635 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41636 ecode2 = SWIG_AsVal_int(obj1, &val2);
41637 if (!SWIG_IsOK(ecode2)) {
41638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41639 }
41640 arg2 = static_cast< int >(val2);
41641 {
41642 PyThreadState* __tstate = wxPyBeginAllowThreads();
41643 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41644 wxPyEndAllowThreads(__tstate);
41645 if (PyErr_Occurred()) SWIG_fail;
41646 }
41647 {
41648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41649 }
41650 return resultobj;
41651 fail:
41652 return NULL;
41653 }
41654
41655
41656 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41657 PyObject *resultobj = 0;
41658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41659 int arg2 ;
41660 wxString *arg3 = 0 ;
41661 void *argp1 = 0 ;
41662 int res1 = 0 ;
41663 int val2 ;
41664 int ecode2 = 0 ;
41665 bool temp3 = false ;
41666 PyObject * obj0 = 0 ;
41667 PyObject * obj1 = 0 ;
41668 PyObject * obj2 = 0 ;
41669 char * kwnames[] = {
41670 (char *) "self",(char *) "id",(char *) "label", NULL
41671 };
41672
41673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41675 if (!SWIG_IsOK(res1)) {
41676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41677 }
41678 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41679 ecode2 = SWIG_AsVal_int(obj1, &val2);
41680 if (!SWIG_IsOK(ecode2)) {
41681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41682 }
41683 arg2 = static_cast< int >(val2);
41684 {
41685 arg3 = wxString_in_helper(obj2);
41686 if (arg3 == NULL) SWIG_fail;
41687 temp3 = true;
41688 }
41689 {
41690 PyThreadState* __tstate = wxPyBeginAllowThreads();
41691 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41692 wxPyEndAllowThreads(__tstate);
41693 if (PyErr_Occurred()) SWIG_fail;
41694 }
41695 resultobj = SWIG_Py_Void();
41696 {
41697 if (temp3)
41698 delete arg3;
41699 }
41700 return resultobj;
41701 fail:
41702 {
41703 if (temp3)
41704 delete arg3;
41705 }
41706 return NULL;
41707 }
41708
41709
41710 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41711 PyObject *resultobj = 0;
41712 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41713 int arg2 ;
41714 wxString result;
41715 void *argp1 = 0 ;
41716 int res1 = 0 ;
41717 int val2 ;
41718 int ecode2 = 0 ;
41719 PyObject * obj0 = 0 ;
41720 PyObject * obj1 = 0 ;
41721 char * kwnames[] = {
41722 (char *) "self",(char *) "id", NULL
41723 };
41724
41725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41727 if (!SWIG_IsOK(res1)) {
41728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41729 }
41730 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41731 ecode2 = SWIG_AsVal_int(obj1, &val2);
41732 if (!SWIG_IsOK(ecode2)) {
41733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41734 }
41735 arg2 = static_cast< int >(val2);
41736 {
41737 PyThreadState* __tstate = wxPyBeginAllowThreads();
41738 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41739 wxPyEndAllowThreads(__tstate);
41740 if (PyErr_Occurred()) SWIG_fail;
41741 }
41742 {
41743 #if wxUSE_UNICODE
41744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41745 #else
41746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41747 #endif
41748 }
41749 return resultobj;
41750 fail:
41751 return NULL;
41752 }
41753
41754
41755 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41756 PyObject *resultobj = 0;
41757 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41758 int arg2 ;
41759 wxString *arg3 = 0 ;
41760 void *argp1 = 0 ;
41761 int res1 = 0 ;
41762 int val2 ;
41763 int ecode2 = 0 ;
41764 bool temp3 = false ;
41765 PyObject * obj0 = 0 ;
41766 PyObject * obj1 = 0 ;
41767 PyObject * obj2 = 0 ;
41768 char * kwnames[] = {
41769 (char *) "self",(char *) "id",(char *) "helpString", NULL
41770 };
41771
41772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41774 if (!SWIG_IsOK(res1)) {
41775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41776 }
41777 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41778 ecode2 = SWIG_AsVal_int(obj1, &val2);
41779 if (!SWIG_IsOK(ecode2)) {
41780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41781 }
41782 arg2 = static_cast< int >(val2);
41783 {
41784 arg3 = wxString_in_helper(obj2);
41785 if (arg3 == NULL) SWIG_fail;
41786 temp3 = true;
41787 }
41788 {
41789 PyThreadState* __tstate = wxPyBeginAllowThreads();
41790 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41791 wxPyEndAllowThreads(__tstate);
41792 if (PyErr_Occurred()) SWIG_fail;
41793 }
41794 resultobj = SWIG_Py_Void();
41795 {
41796 if (temp3)
41797 delete arg3;
41798 }
41799 return resultobj;
41800 fail:
41801 {
41802 if (temp3)
41803 delete arg3;
41804 }
41805 return NULL;
41806 }
41807
41808
41809 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41810 PyObject *resultobj = 0;
41811 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41812 int arg2 ;
41813 wxString result;
41814 void *argp1 = 0 ;
41815 int res1 = 0 ;
41816 int val2 ;
41817 int ecode2 = 0 ;
41818 PyObject * obj0 = 0 ;
41819 PyObject * obj1 = 0 ;
41820 char * kwnames[] = {
41821 (char *) "self",(char *) "id", NULL
41822 };
41823
41824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41826 if (!SWIG_IsOK(res1)) {
41827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41828 }
41829 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41830 ecode2 = SWIG_AsVal_int(obj1, &val2);
41831 if (!SWIG_IsOK(ecode2)) {
41832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41833 }
41834 arg2 = static_cast< int >(val2);
41835 {
41836 PyThreadState* __tstate = wxPyBeginAllowThreads();
41837 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41838 wxPyEndAllowThreads(__tstate);
41839 if (PyErr_Occurred()) SWIG_fail;
41840 }
41841 {
41842 #if wxUSE_UNICODE
41843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41844 #else
41845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41846 #endif
41847 }
41848 return resultobj;
41849 fail:
41850 return NULL;
41851 }
41852
41853
41854 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41855 PyObject *resultobj = 0;
41856 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41857 wxFrame *result = 0 ;
41858 void *argp1 = 0 ;
41859 int res1 = 0 ;
41860 PyObject *swig_obj[1] ;
41861
41862 if (!args) SWIG_fail;
41863 swig_obj[0] = args;
41864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41865 if (!SWIG_IsOK(res1)) {
41866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41867 }
41868 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41869 {
41870 PyThreadState* __tstate = wxPyBeginAllowThreads();
41871 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41872 wxPyEndAllowThreads(__tstate);
41873 if (PyErr_Occurred()) SWIG_fail;
41874 }
41875 {
41876 resultobj = wxPyMake_wxObject(result, (bool)0);
41877 }
41878 return resultobj;
41879 fail:
41880 return NULL;
41881 }
41882
41883
41884 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41885 PyObject *resultobj = 0;
41886 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41887 bool result;
41888 void *argp1 = 0 ;
41889 int res1 = 0 ;
41890 PyObject *swig_obj[1] ;
41891
41892 if (!args) SWIG_fail;
41893 swig_obj[0] = args;
41894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41895 if (!SWIG_IsOK(res1)) {
41896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41897 }
41898 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41899 {
41900 PyThreadState* __tstate = wxPyBeginAllowThreads();
41901 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41902 wxPyEndAllowThreads(__tstate);
41903 if (PyErr_Occurred()) SWIG_fail;
41904 }
41905 {
41906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41907 }
41908 return resultobj;
41909 fail:
41910 return NULL;
41911 }
41912
41913
41914 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41915 PyObject *resultobj = 0;
41916 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41917 wxFrame *arg2 = (wxFrame *) 0 ;
41918 void *argp1 = 0 ;
41919 int res1 = 0 ;
41920 void *argp2 = 0 ;
41921 int res2 = 0 ;
41922 PyObject * obj0 = 0 ;
41923 PyObject * obj1 = 0 ;
41924 char * kwnames[] = {
41925 (char *) "self",(char *) "frame", NULL
41926 };
41927
41928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41930 if (!SWIG_IsOK(res1)) {
41931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41932 }
41933 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41935 if (!SWIG_IsOK(res2)) {
41936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41937 }
41938 arg2 = reinterpret_cast< wxFrame * >(argp2);
41939 {
41940 PyThreadState* __tstate = wxPyBeginAllowThreads();
41941 (arg1)->Attach(arg2);
41942 wxPyEndAllowThreads(__tstate);
41943 if (PyErr_Occurred()) SWIG_fail;
41944 }
41945 resultobj = SWIG_Py_Void();
41946 return resultobj;
41947 fail:
41948 return NULL;
41949 }
41950
41951
41952 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41953 PyObject *resultobj = 0;
41954 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41955 void *argp1 = 0 ;
41956 int res1 = 0 ;
41957 PyObject *swig_obj[1] ;
41958
41959 if (!args) SWIG_fail;
41960 swig_obj[0] = args;
41961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41962 if (!SWIG_IsOK(res1)) {
41963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41964 }
41965 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41966 {
41967 PyThreadState* __tstate = wxPyBeginAllowThreads();
41968 (arg1)->Detach();
41969 wxPyEndAllowThreads(__tstate);
41970 if (PyErr_Occurred()) SWIG_fail;
41971 }
41972 resultobj = SWIG_Py_Void();
41973 return resultobj;
41974 fail:
41975 return NULL;
41976 }
41977
41978
41979 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41980 PyObject *resultobj = 0;
41981 bool arg1 ;
41982 bool val1 ;
41983 int ecode1 = 0 ;
41984 PyObject * obj0 = 0 ;
41985 char * kwnames[] = {
41986 (char *) "enable", NULL
41987 };
41988
41989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41990 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41991 if (!SWIG_IsOK(ecode1)) {
41992 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41993 }
41994 arg1 = static_cast< bool >(val1);
41995 {
41996 PyThreadState* __tstate = wxPyBeginAllowThreads();
41997 wxMenuBar_SetAutoWindowMenu(arg1);
41998 wxPyEndAllowThreads(__tstate);
41999 if (PyErr_Occurred()) SWIG_fail;
42000 }
42001 resultobj = SWIG_Py_Void();
42002 return resultobj;
42003 fail:
42004 return NULL;
42005 }
42006
42007
42008 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42009 PyObject *resultobj = 0;
42010 bool result;
42011
42012 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42013 {
42014 PyThreadState* __tstate = wxPyBeginAllowThreads();
42015 result = (bool)wxMenuBar_GetAutoWindowMenu();
42016 wxPyEndAllowThreads(__tstate);
42017 if (PyErr_Occurred()) SWIG_fail;
42018 }
42019 {
42020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42021 }
42022 return resultobj;
42023 fail:
42024 return NULL;
42025 }
42026
42027
42028 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42029 PyObject *obj;
42030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42031 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42032 return SWIG_Py_Void();
42033 }
42034
42035 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42036 return SWIG_Python_InitShadowInstance(args);
42037 }
42038
42039 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42040 PyObject *resultobj = 0;
42041 wxMenu *arg1 = (wxMenu *) NULL ;
42042 int arg2 = (int) wxID_ANY ;
42043 wxString const &arg3_defvalue = wxPyEmptyString ;
42044 wxString *arg3 = (wxString *) &arg3_defvalue ;
42045 wxString const &arg4_defvalue = wxPyEmptyString ;
42046 wxString *arg4 = (wxString *) &arg4_defvalue ;
42047 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42048 wxMenu *arg6 = (wxMenu *) NULL ;
42049 wxMenuItem *result = 0 ;
42050 void *argp1 = 0 ;
42051 int res1 = 0 ;
42052 int val2 ;
42053 int ecode2 = 0 ;
42054 bool temp3 = false ;
42055 bool temp4 = false ;
42056 int val5 ;
42057 int ecode5 = 0 ;
42058 void *argp6 = 0 ;
42059 int res6 = 0 ;
42060 PyObject * obj0 = 0 ;
42061 PyObject * obj1 = 0 ;
42062 PyObject * obj2 = 0 ;
42063 PyObject * obj3 = 0 ;
42064 PyObject * obj4 = 0 ;
42065 PyObject * obj5 = 0 ;
42066 char * kwnames[] = {
42067 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42068 };
42069
42070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42071 if (obj0) {
42072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42073 if (!SWIG_IsOK(res1)) {
42074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42075 }
42076 arg1 = reinterpret_cast< wxMenu * >(argp1);
42077 }
42078 if (obj1) {
42079 ecode2 = SWIG_AsVal_int(obj1, &val2);
42080 if (!SWIG_IsOK(ecode2)) {
42081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42082 }
42083 arg2 = static_cast< int >(val2);
42084 }
42085 if (obj2) {
42086 {
42087 arg3 = wxString_in_helper(obj2);
42088 if (arg3 == NULL) SWIG_fail;
42089 temp3 = true;
42090 }
42091 }
42092 if (obj3) {
42093 {
42094 arg4 = wxString_in_helper(obj3);
42095 if (arg4 == NULL) SWIG_fail;
42096 temp4 = true;
42097 }
42098 }
42099 if (obj4) {
42100 ecode5 = SWIG_AsVal_int(obj4, &val5);
42101 if (!SWIG_IsOK(ecode5)) {
42102 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42103 }
42104 arg5 = static_cast< wxItemKind >(val5);
42105 }
42106 if (obj5) {
42107 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42108 if (!SWIG_IsOK(res6)) {
42109 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42110 }
42111 arg6 = reinterpret_cast< wxMenu * >(argp6);
42112 }
42113 {
42114 PyThreadState* __tstate = wxPyBeginAllowThreads();
42115 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42116 wxPyEndAllowThreads(__tstate);
42117 if (PyErr_Occurred()) SWIG_fail;
42118 }
42119 {
42120 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42121 }
42122 {
42123 if (temp3)
42124 delete arg3;
42125 }
42126 {
42127 if (temp4)
42128 delete arg4;
42129 }
42130 return resultobj;
42131 fail:
42132 {
42133 if (temp3)
42134 delete arg3;
42135 }
42136 {
42137 if (temp4)
42138 delete arg4;
42139 }
42140 return NULL;
42141 }
42142
42143
42144 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42145 PyObject *resultobj = 0;
42146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42147 void *argp1 = 0 ;
42148 int res1 = 0 ;
42149 PyObject *swig_obj[1] ;
42150
42151 if (!args) SWIG_fail;
42152 swig_obj[0] = args;
42153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42154 if (!SWIG_IsOK(res1)) {
42155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42156 }
42157 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42158 {
42159 PyThreadState* __tstate = wxPyBeginAllowThreads();
42160 delete arg1;
42161
42162 wxPyEndAllowThreads(__tstate);
42163 if (PyErr_Occurred()) SWIG_fail;
42164 }
42165 resultobj = SWIG_Py_Void();
42166 return resultobj;
42167 fail:
42168 return NULL;
42169 }
42170
42171
42172 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42173 PyObject *resultobj = 0;
42174 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42175 wxMenu *result = 0 ;
42176 void *argp1 = 0 ;
42177 int res1 = 0 ;
42178 PyObject *swig_obj[1] ;
42179
42180 if (!args) SWIG_fail;
42181 swig_obj[0] = args;
42182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42183 if (!SWIG_IsOK(res1)) {
42184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42185 }
42186 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42187 {
42188 PyThreadState* __tstate = wxPyBeginAllowThreads();
42189 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42190 wxPyEndAllowThreads(__tstate);
42191 if (PyErr_Occurred()) SWIG_fail;
42192 }
42193 {
42194 resultobj = wxPyMake_wxObject(result, 0);
42195 }
42196 return resultobj;
42197 fail:
42198 return NULL;
42199 }
42200
42201
42202 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42203 PyObject *resultobj = 0;
42204 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42205 wxMenu *arg2 = (wxMenu *) 0 ;
42206 void *argp1 = 0 ;
42207 int res1 = 0 ;
42208 void *argp2 = 0 ;
42209 int res2 = 0 ;
42210 PyObject * obj0 = 0 ;
42211 PyObject * obj1 = 0 ;
42212 char * kwnames[] = {
42213 (char *) "self",(char *) "menu", NULL
42214 };
42215
42216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42218 if (!SWIG_IsOK(res1)) {
42219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42220 }
42221 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42223 if (!SWIG_IsOK(res2)) {
42224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42225 }
42226 arg2 = reinterpret_cast< wxMenu * >(argp2);
42227 {
42228 PyThreadState* __tstate = wxPyBeginAllowThreads();
42229 (arg1)->SetMenu(arg2);
42230 wxPyEndAllowThreads(__tstate);
42231 if (PyErr_Occurred()) SWIG_fail;
42232 }
42233 resultobj = SWIG_Py_Void();
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42241 PyObject *resultobj = 0;
42242 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42243 int arg2 ;
42244 void *argp1 = 0 ;
42245 int res1 = 0 ;
42246 int val2 ;
42247 int ecode2 = 0 ;
42248 PyObject * obj0 = 0 ;
42249 PyObject * obj1 = 0 ;
42250 char * kwnames[] = {
42251 (char *) "self",(char *) "id", NULL
42252 };
42253
42254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42256 if (!SWIG_IsOK(res1)) {
42257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42258 }
42259 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42260 ecode2 = SWIG_AsVal_int(obj1, &val2);
42261 if (!SWIG_IsOK(ecode2)) {
42262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42263 }
42264 arg2 = static_cast< int >(val2);
42265 {
42266 PyThreadState* __tstate = wxPyBeginAllowThreads();
42267 (arg1)->SetId(arg2);
42268 wxPyEndAllowThreads(__tstate);
42269 if (PyErr_Occurred()) SWIG_fail;
42270 }
42271 resultobj = SWIG_Py_Void();
42272 return resultobj;
42273 fail:
42274 return NULL;
42275 }
42276
42277
42278 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42279 PyObject *resultobj = 0;
42280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42281 int result;
42282 void *argp1 = 0 ;
42283 int res1 = 0 ;
42284 PyObject *swig_obj[1] ;
42285
42286 if (!args) SWIG_fail;
42287 swig_obj[0] = args;
42288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42289 if (!SWIG_IsOK(res1)) {
42290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42291 }
42292 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42293 {
42294 PyThreadState* __tstate = wxPyBeginAllowThreads();
42295 result = (int)((wxMenuItem const *)arg1)->GetId();
42296 wxPyEndAllowThreads(__tstate);
42297 if (PyErr_Occurred()) SWIG_fail;
42298 }
42299 resultobj = SWIG_From_int(static_cast< int >(result));
42300 return resultobj;
42301 fail:
42302 return NULL;
42303 }
42304
42305
42306 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42307 PyObject *resultobj = 0;
42308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42309 bool result;
42310 void *argp1 = 0 ;
42311 int res1 = 0 ;
42312 PyObject *swig_obj[1] ;
42313
42314 if (!args) SWIG_fail;
42315 swig_obj[0] = args;
42316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42317 if (!SWIG_IsOK(res1)) {
42318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42319 }
42320 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42321 {
42322 PyThreadState* __tstate = wxPyBeginAllowThreads();
42323 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42324 wxPyEndAllowThreads(__tstate);
42325 if (PyErr_Occurred()) SWIG_fail;
42326 }
42327 {
42328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42329 }
42330 return resultobj;
42331 fail:
42332 return NULL;
42333 }
42334
42335
42336 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42337 PyObject *resultobj = 0;
42338 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42339 wxString *arg2 = 0 ;
42340 void *argp1 = 0 ;
42341 int res1 = 0 ;
42342 bool temp2 = false ;
42343 PyObject * obj0 = 0 ;
42344 PyObject * obj1 = 0 ;
42345 char * kwnames[] = {
42346 (char *) "self",(char *) "str", NULL
42347 };
42348
42349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42351 if (!SWIG_IsOK(res1)) {
42352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42353 }
42354 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42355 {
42356 arg2 = wxString_in_helper(obj1);
42357 if (arg2 == NULL) SWIG_fail;
42358 temp2 = true;
42359 }
42360 {
42361 PyThreadState* __tstate = wxPyBeginAllowThreads();
42362 (arg1)->SetText((wxString const &)*arg2);
42363 wxPyEndAllowThreads(__tstate);
42364 if (PyErr_Occurred()) SWIG_fail;
42365 }
42366 resultobj = SWIG_Py_Void();
42367 {
42368 if (temp2)
42369 delete arg2;
42370 }
42371 return resultobj;
42372 fail:
42373 {
42374 if (temp2)
42375 delete arg2;
42376 }
42377 return NULL;
42378 }
42379
42380
42381 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42382 PyObject *resultobj = 0;
42383 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42384 wxString result;
42385 void *argp1 = 0 ;
42386 int res1 = 0 ;
42387 PyObject *swig_obj[1] ;
42388
42389 if (!args) SWIG_fail;
42390 swig_obj[0] = args;
42391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42392 if (!SWIG_IsOK(res1)) {
42393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42394 }
42395 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42396 {
42397 PyThreadState* __tstate = wxPyBeginAllowThreads();
42398 result = ((wxMenuItem const *)arg1)->GetLabel();
42399 wxPyEndAllowThreads(__tstate);
42400 if (PyErr_Occurred()) SWIG_fail;
42401 }
42402 {
42403 #if wxUSE_UNICODE
42404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42405 #else
42406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42407 #endif
42408 }
42409 return resultobj;
42410 fail:
42411 return NULL;
42412 }
42413
42414
42415 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42416 PyObject *resultobj = 0;
42417 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42418 wxString *result = 0 ;
42419 void *argp1 = 0 ;
42420 int res1 = 0 ;
42421 PyObject *swig_obj[1] ;
42422
42423 if (!args) SWIG_fail;
42424 swig_obj[0] = args;
42425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42426 if (!SWIG_IsOK(res1)) {
42427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42428 }
42429 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42430 {
42431 PyThreadState* __tstate = wxPyBeginAllowThreads();
42432 {
42433 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42434 result = (wxString *) &_result_ref;
42435 }
42436 wxPyEndAllowThreads(__tstate);
42437 if (PyErr_Occurred()) SWIG_fail;
42438 }
42439 {
42440 #if wxUSE_UNICODE
42441 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42442 #else
42443 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42444 #endif
42445 }
42446 return resultobj;
42447 fail:
42448 return NULL;
42449 }
42450
42451
42452 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42453 PyObject *resultobj = 0;
42454 wxString *arg1 = 0 ;
42455 wxString result;
42456 bool temp1 = false ;
42457 PyObject * obj0 = 0 ;
42458 char * kwnames[] = {
42459 (char *) "text", NULL
42460 };
42461
42462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42463 {
42464 arg1 = wxString_in_helper(obj0);
42465 if (arg1 == NULL) SWIG_fail;
42466 temp1 = true;
42467 }
42468 {
42469 PyThreadState* __tstate = wxPyBeginAllowThreads();
42470 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42471 wxPyEndAllowThreads(__tstate);
42472 if (PyErr_Occurred()) SWIG_fail;
42473 }
42474 {
42475 #if wxUSE_UNICODE
42476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42477 #else
42478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42479 #endif
42480 }
42481 {
42482 if (temp1)
42483 delete arg1;
42484 }
42485 return resultobj;
42486 fail:
42487 {
42488 if (temp1)
42489 delete arg1;
42490 }
42491 return NULL;
42492 }
42493
42494
42495 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42496 PyObject *resultobj = 0;
42497 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42498 wxItemKind result;
42499 void *argp1 = 0 ;
42500 int res1 = 0 ;
42501 PyObject *swig_obj[1] ;
42502
42503 if (!args) SWIG_fail;
42504 swig_obj[0] = args;
42505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42506 if (!SWIG_IsOK(res1)) {
42507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42508 }
42509 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42510 {
42511 PyThreadState* __tstate = wxPyBeginAllowThreads();
42512 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42513 wxPyEndAllowThreads(__tstate);
42514 if (PyErr_Occurred()) SWIG_fail;
42515 }
42516 resultobj = SWIG_From_int(static_cast< int >(result));
42517 return resultobj;
42518 fail:
42519 return NULL;
42520 }
42521
42522
42523 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42524 PyObject *resultobj = 0;
42525 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42526 wxItemKind arg2 ;
42527 void *argp1 = 0 ;
42528 int res1 = 0 ;
42529 int val2 ;
42530 int ecode2 = 0 ;
42531 PyObject * obj0 = 0 ;
42532 PyObject * obj1 = 0 ;
42533 char * kwnames[] = {
42534 (char *) "self",(char *) "kind", NULL
42535 };
42536
42537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42539 if (!SWIG_IsOK(res1)) {
42540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42541 }
42542 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42543 ecode2 = SWIG_AsVal_int(obj1, &val2);
42544 if (!SWIG_IsOK(ecode2)) {
42545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42546 }
42547 arg2 = static_cast< wxItemKind >(val2);
42548 {
42549 PyThreadState* __tstate = wxPyBeginAllowThreads();
42550 (arg1)->SetKind(arg2);
42551 wxPyEndAllowThreads(__tstate);
42552 if (PyErr_Occurred()) SWIG_fail;
42553 }
42554 resultobj = SWIG_Py_Void();
42555 return resultobj;
42556 fail:
42557 return NULL;
42558 }
42559
42560
42561 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42562 PyObject *resultobj = 0;
42563 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42564 bool arg2 ;
42565 void *argp1 = 0 ;
42566 int res1 = 0 ;
42567 bool val2 ;
42568 int ecode2 = 0 ;
42569 PyObject * obj0 = 0 ;
42570 PyObject * obj1 = 0 ;
42571 char * kwnames[] = {
42572 (char *) "self",(char *) "checkable", NULL
42573 };
42574
42575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42577 if (!SWIG_IsOK(res1)) {
42578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42579 }
42580 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42581 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42582 if (!SWIG_IsOK(ecode2)) {
42583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42584 }
42585 arg2 = static_cast< bool >(val2);
42586 {
42587 PyThreadState* __tstate = wxPyBeginAllowThreads();
42588 (arg1)->SetCheckable(arg2);
42589 wxPyEndAllowThreads(__tstate);
42590 if (PyErr_Occurred()) SWIG_fail;
42591 }
42592 resultobj = SWIG_Py_Void();
42593 return resultobj;
42594 fail:
42595 return NULL;
42596 }
42597
42598
42599 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42600 PyObject *resultobj = 0;
42601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42602 bool result;
42603 void *argp1 = 0 ;
42604 int res1 = 0 ;
42605 PyObject *swig_obj[1] ;
42606
42607 if (!args) SWIG_fail;
42608 swig_obj[0] = args;
42609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42610 if (!SWIG_IsOK(res1)) {
42611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42612 }
42613 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42614 {
42615 PyThreadState* __tstate = wxPyBeginAllowThreads();
42616 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 {
42621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42622 }
42623 return resultobj;
42624 fail:
42625 return NULL;
42626 }
42627
42628
42629 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42630 PyObject *resultobj = 0;
42631 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42632 bool result;
42633 void *argp1 = 0 ;
42634 int res1 = 0 ;
42635 PyObject *swig_obj[1] ;
42636
42637 if (!args) SWIG_fail;
42638 swig_obj[0] = args;
42639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42640 if (!SWIG_IsOK(res1)) {
42641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42642 }
42643 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42644 {
42645 PyThreadState* __tstate = wxPyBeginAllowThreads();
42646 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42647 wxPyEndAllowThreads(__tstate);
42648 if (PyErr_Occurred()) SWIG_fail;
42649 }
42650 {
42651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42652 }
42653 return resultobj;
42654 fail:
42655 return NULL;
42656 }
42657
42658
42659 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42660 PyObject *resultobj = 0;
42661 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42662 wxMenu *arg2 = (wxMenu *) 0 ;
42663 void *argp1 = 0 ;
42664 int res1 = 0 ;
42665 void *argp2 = 0 ;
42666 int res2 = 0 ;
42667 PyObject * obj0 = 0 ;
42668 PyObject * obj1 = 0 ;
42669 char * kwnames[] = {
42670 (char *) "self",(char *) "menu", NULL
42671 };
42672
42673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42675 if (!SWIG_IsOK(res1)) {
42676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42677 }
42678 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42680 if (!SWIG_IsOK(res2)) {
42681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42682 }
42683 arg2 = reinterpret_cast< wxMenu * >(argp2);
42684 {
42685 PyThreadState* __tstate = wxPyBeginAllowThreads();
42686 (arg1)->SetSubMenu(arg2);
42687 wxPyEndAllowThreads(__tstate);
42688 if (PyErr_Occurred()) SWIG_fail;
42689 }
42690 resultobj = SWIG_Py_Void();
42691 return resultobj;
42692 fail:
42693 return NULL;
42694 }
42695
42696
42697 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42698 PyObject *resultobj = 0;
42699 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42700 wxMenu *result = 0 ;
42701 void *argp1 = 0 ;
42702 int res1 = 0 ;
42703 PyObject *swig_obj[1] ;
42704
42705 if (!args) SWIG_fail;
42706 swig_obj[0] = args;
42707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42708 if (!SWIG_IsOK(res1)) {
42709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42710 }
42711 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42712 {
42713 PyThreadState* __tstate = wxPyBeginAllowThreads();
42714 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42715 wxPyEndAllowThreads(__tstate);
42716 if (PyErr_Occurred()) SWIG_fail;
42717 }
42718 {
42719 resultobj = wxPyMake_wxObject(result, 0);
42720 }
42721 return resultobj;
42722 fail:
42723 return NULL;
42724 }
42725
42726
42727 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42728 PyObject *resultobj = 0;
42729 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42730 bool arg2 = (bool) true ;
42731 void *argp1 = 0 ;
42732 int res1 = 0 ;
42733 bool val2 ;
42734 int ecode2 = 0 ;
42735 PyObject * obj0 = 0 ;
42736 PyObject * obj1 = 0 ;
42737 char * kwnames[] = {
42738 (char *) "self",(char *) "enable", NULL
42739 };
42740
42741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42743 if (!SWIG_IsOK(res1)) {
42744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42745 }
42746 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42747 if (obj1) {
42748 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42749 if (!SWIG_IsOK(ecode2)) {
42750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42751 }
42752 arg2 = static_cast< bool >(val2);
42753 }
42754 {
42755 PyThreadState* __tstate = wxPyBeginAllowThreads();
42756 (arg1)->Enable(arg2);
42757 wxPyEndAllowThreads(__tstate);
42758 if (PyErr_Occurred()) SWIG_fail;
42759 }
42760 resultobj = SWIG_Py_Void();
42761 return resultobj;
42762 fail:
42763 return NULL;
42764 }
42765
42766
42767 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42768 PyObject *resultobj = 0;
42769 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42770 bool result;
42771 void *argp1 = 0 ;
42772 int res1 = 0 ;
42773 PyObject *swig_obj[1] ;
42774
42775 if (!args) SWIG_fail;
42776 swig_obj[0] = args;
42777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42778 if (!SWIG_IsOK(res1)) {
42779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42780 }
42781 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42782 {
42783 PyThreadState* __tstate = wxPyBeginAllowThreads();
42784 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42785 wxPyEndAllowThreads(__tstate);
42786 if (PyErr_Occurred()) SWIG_fail;
42787 }
42788 {
42789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42790 }
42791 return resultobj;
42792 fail:
42793 return NULL;
42794 }
42795
42796
42797 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42798 PyObject *resultobj = 0;
42799 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42800 bool arg2 = (bool) true ;
42801 void *argp1 = 0 ;
42802 int res1 = 0 ;
42803 bool val2 ;
42804 int ecode2 = 0 ;
42805 PyObject * obj0 = 0 ;
42806 PyObject * obj1 = 0 ;
42807 char * kwnames[] = {
42808 (char *) "self",(char *) "check", NULL
42809 };
42810
42811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42813 if (!SWIG_IsOK(res1)) {
42814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42815 }
42816 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42817 if (obj1) {
42818 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42819 if (!SWIG_IsOK(ecode2)) {
42820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42821 }
42822 arg2 = static_cast< bool >(val2);
42823 }
42824 {
42825 PyThreadState* __tstate = wxPyBeginAllowThreads();
42826 (arg1)->Check(arg2);
42827 wxPyEndAllowThreads(__tstate);
42828 if (PyErr_Occurred()) SWIG_fail;
42829 }
42830 resultobj = SWIG_Py_Void();
42831 return resultobj;
42832 fail:
42833 return NULL;
42834 }
42835
42836
42837 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42838 PyObject *resultobj = 0;
42839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42840 bool result;
42841 void *argp1 = 0 ;
42842 int res1 = 0 ;
42843 PyObject *swig_obj[1] ;
42844
42845 if (!args) SWIG_fail;
42846 swig_obj[0] = args;
42847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42848 if (!SWIG_IsOK(res1)) {
42849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42850 }
42851 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42852 {
42853 PyThreadState* __tstate = wxPyBeginAllowThreads();
42854 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42855 wxPyEndAllowThreads(__tstate);
42856 if (PyErr_Occurred()) SWIG_fail;
42857 }
42858 {
42859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42860 }
42861 return resultobj;
42862 fail:
42863 return NULL;
42864 }
42865
42866
42867 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42868 PyObject *resultobj = 0;
42869 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42870 void *argp1 = 0 ;
42871 int res1 = 0 ;
42872 PyObject *swig_obj[1] ;
42873
42874 if (!args) SWIG_fail;
42875 swig_obj[0] = args;
42876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42877 if (!SWIG_IsOK(res1)) {
42878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42879 }
42880 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42881 {
42882 PyThreadState* __tstate = wxPyBeginAllowThreads();
42883 (arg1)->Toggle();
42884 wxPyEndAllowThreads(__tstate);
42885 if (PyErr_Occurred()) SWIG_fail;
42886 }
42887 resultobj = SWIG_Py_Void();
42888 return resultobj;
42889 fail:
42890 return NULL;
42891 }
42892
42893
42894 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42895 PyObject *resultobj = 0;
42896 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42897 wxString *arg2 = 0 ;
42898 void *argp1 = 0 ;
42899 int res1 = 0 ;
42900 bool temp2 = false ;
42901 PyObject * obj0 = 0 ;
42902 PyObject * obj1 = 0 ;
42903 char * kwnames[] = {
42904 (char *) "self",(char *) "str", NULL
42905 };
42906
42907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42909 if (!SWIG_IsOK(res1)) {
42910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42911 }
42912 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42913 {
42914 arg2 = wxString_in_helper(obj1);
42915 if (arg2 == NULL) SWIG_fail;
42916 temp2 = true;
42917 }
42918 {
42919 PyThreadState* __tstate = wxPyBeginAllowThreads();
42920 (arg1)->SetHelp((wxString const &)*arg2);
42921 wxPyEndAllowThreads(__tstate);
42922 if (PyErr_Occurred()) SWIG_fail;
42923 }
42924 resultobj = SWIG_Py_Void();
42925 {
42926 if (temp2)
42927 delete arg2;
42928 }
42929 return resultobj;
42930 fail:
42931 {
42932 if (temp2)
42933 delete arg2;
42934 }
42935 return NULL;
42936 }
42937
42938
42939 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42940 PyObject *resultobj = 0;
42941 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42942 wxString *result = 0 ;
42943 void *argp1 = 0 ;
42944 int res1 = 0 ;
42945 PyObject *swig_obj[1] ;
42946
42947 if (!args) SWIG_fail;
42948 swig_obj[0] = args;
42949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42950 if (!SWIG_IsOK(res1)) {
42951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42952 }
42953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42954 {
42955 PyThreadState* __tstate = wxPyBeginAllowThreads();
42956 {
42957 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42958 result = (wxString *) &_result_ref;
42959 }
42960 wxPyEndAllowThreads(__tstate);
42961 if (PyErr_Occurred()) SWIG_fail;
42962 }
42963 {
42964 #if wxUSE_UNICODE
42965 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42966 #else
42967 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42968 #endif
42969 }
42970 return resultobj;
42971 fail:
42972 return NULL;
42973 }
42974
42975
42976 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42977 PyObject *resultobj = 0;
42978 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42979 wxAcceleratorEntry *result = 0 ;
42980 void *argp1 = 0 ;
42981 int res1 = 0 ;
42982 PyObject *swig_obj[1] ;
42983
42984 if (!args) SWIG_fail;
42985 swig_obj[0] = args;
42986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42987 if (!SWIG_IsOK(res1)) {
42988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42989 }
42990 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42991 {
42992 PyThreadState* __tstate = wxPyBeginAllowThreads();
42993 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42994 wxPyEndAllowThreads(__tstate);
42995 if (PyErr_Occurred()) SWIG_fail;
42996 }
42997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42998 return resultobj;
42999 fail:
43000 return NULL;
43001 }
43002
43003
43004 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43005 PyObject *resultobj = 0;
43006 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43007 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43008 void *argp1 = 0 ;
43009 int res1 = 0 ;
43010 void *argp2 = 0 ;
43011 int res2 = 0 ;
43012 PyObject * obj0 = 0 ;
43013 PyObject * obj1 = 0 ;
43014 char * kwnames[] = {
43015 (char *) "self",(char *) "accel", NULL
43016 };
43017
43018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43020 if (!SWIG_IsOK(res1)) {
43021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43022 }
43023 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43025 if (!SWIG_IsOK(res2)) {
43026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43027 }
43028 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43029 {
43030 PyThreadState* __tstate = wxPyBeginAllowThreads();
43031 (arg1)->SetAccel(arg2);
43032 wxPyEndAllowThreads(__tstate);
43033 if (PyErr_Occurred()) SWIG_fail;
43034 }
43035 resultobj = SWIG_Py_Void();
43036 return resultobj;
43037 fail:
43038 return NULL;
43039 }
43040
43041
43042 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43043 PyObject *resultobj = 0;
43044 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43045 wxBitmap *arg2 = 0 ;
43046 void *argp1 = 0 ;
43047 int res1 = 0 ;
43048 void *argp2 = 0 ;
43049 int res2 = 0 ;
43050 PyObject * obj0 = 0 ;
43051 PyObject * obj1 = 0 ;
43052 char * kwnames[] = {
43053 (char *) "self",(char *) "bitmap", NULL
43054 };
43055
43056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43058 if (!SWIG_IsOK(res1)) {
43059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43060 }
43061 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43062 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43063 if (!SWIG_IsOK(res2)) {
43064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43065 }
43066 if (!argp2) {
43067 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43068 }
43069 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43070 {
43071 PyThreadState* __tstate = wxPyBeginAllowThreads();
43072 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43073 wxPyEndAllowThreads(__tstate);
43074 if (PyErr_Occurred()) SWIG_fail;
43075 }
43076 resultobj = SWIG_Py_Void();
43077 return resultobj;
43078 fail:
43079 return NULL;
43080 }
43081
43082
43083 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43084 PyObject *resultobj = 0;
43085 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43086 wxBitmap *result = 0 ;
43087 void *argp1 = 0 ;
43088 int res1 = 0 ;
43089 PyObject *swig_obj[1] ;
43090
43091 if (!args) SWIG_fail;
43092 swig_obj[0] = args;
43093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43094 if (!SWIG_IsOK(res1)) {
43095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43096 }
43097 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43098 {
43099 PyThreadState* __tstate = wxPyBeginAllowThreads();
43100 {
43101 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43102 result = (wxBitmap *) &_result_ref;
43103 }
43104 wxPyEndAllowThreads(__tstate);
43105 if (PyErr_Occurred()) SWIG_fail;
43106 }
43107 {
43108 wxBitmap* resultptr = new wxBitmap(*result);
43109 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43110 }
43111 return resultobj;
43112 fail:
43113 return NULL;
43114 }
43115
43116
43117 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43118 PyObject *resultobj = 0;
43119 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43120 wxFont *arg2 = 0 ;
43121 void *argp1 = 0 ;
43122 int res1 = 0 ;
43123 void *argp2 = 0 ;
43124 int res2 = 0 ;
43125 PyObject * obj0 = 0 ;
43126 PyObject * obj1 = 0 ;
43127 char * kwnames[] = {
43128 (char *) "self",(char *) "font", NULL
43129 };
43130
43131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43133 if (!SWIG_IsOK(res1)) {
43134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43135 }
43136 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43137 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43138 if (!SWIG_IsOK(res2)) {
43139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43140 }
43141 if (!argp2) {
43142 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43143 }
43144 arg2 = reinterpret_cast< wxFont * >(argp2);
43145 {
43146 PyThreadState* __tstate = wxPyBeginAllowThreads();
43147 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43148 wxPyEndAllowThreads(__tstate);
43149 if (PyErr_Occurred()) SWIG_fail;
43150 }
43151 resultobj = SWIG_Py_Void();
43152 return resultobj;
43153 fail:
43154 return NULL;
43155 }
43156
43157
43158 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43159 PyObject *resultobj = 0;
43160 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43161 wxFont result;
43162 void *argp1 = 0 ;
43163 int res1 = 0 ;
43164 PyObject *swig_obj[1] ;
43165
43166 if (!args) SWIG_fail;
43167 swig_obj[0] = args;
43168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43169 if (!SWIG_IsOK(res1)) {
43170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43171 }
43172 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43173 {
43174 PyThreadState* __tstate = wxPyBeginAllowThreads();
43175 result = wxMenuItem_GetFont(arg1);
43176 wxPyEndAllowThreads(__tstate);
43177 if (PyErr_Occurred()) SWIG_fail;
43178 }
43179 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43180 return resultobj;
43181 fail:
43182 return NULL;
43183 }
43184
43185
43186 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43187 PyObject *resultobj = 0;
43188 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43189 wxColour *arg2 = 0 ;
43190 void *argp1 = 0 ;
43191 int res1 = 0 ;
43192 wxColour temp2 ;
43193 PyObject * obj0 = 0 ;
43194 PyObject * obj1 = 0 ;
43195 char * kwnames[] = {
43196 (char *) "self",(char *) "colText", NULL
43197 };
43198
43199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43201 if (!SWIG_IsOK(res1)) {
43202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43203 }
43204 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43205 {
43206 arg2 = &temp2;
43207 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43208 }
43209 {
43210 PyThreadState* __tstate = wxPyBeginAllowThreads();
43211 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43212 wxPyEndAllowThreads(__tstate);
43213 if (PyErr_Occurred()) SWIG_fail;
43214 }
43215 resultobj = SWIG_Py_Void();
43216 return resultobj;
43217 fail:
43218 return NULL;
43219 }
43220
43221
43222 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43223 PyObject *resultobj = 0;
43224 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43225 wxColour result;
43226 void *argp1 = 0 ;
43227 int res1 = 0 ;
43228 PyObject *swig_obj[1] ;
43229
43230 if (!args) SWIG_fail;
43231 swig_obj[0] = args;
43232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43233 if (!SWIG_IsOK(res1)) {
43234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43235 }
43236 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43237 {
43238 PyThreadState* __tstate = wxPyBeginAllowThreads();
43239 result = wxMenuItem_GetTextColour(arg1);
43240 wxPyEndAllowThreads(__tstate);
43241 if (PyErr_Occurred()) SWIG_fail;
43242 }
43243 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43244 return resultobj;
43245 fail:
43246 return NULL;
43247 }
43248
43249
43250 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43251 PyObject *resultobj = 0;
43252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43253 wxColour *arg2 = 0 ;
43254 void *argp1 = 0 ;
43255 int res1 = 0 ;
43256 wxColour temp2 ;
43257 PyObject * obj0 = 0 ;
43258 PyObject * obj1 = 0 ;
43259 char * kwnames[] = {
43260 (char *) "self",(char *) "colBack", NULL
43261 };
43262
43263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43265 if (!SWIG_IsOK(res1)) {
43266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43267 }
43268 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43269 {
43270 arg2 = &temp2;
43271 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43272 }
43273 {
43274 PyThreadState* __tstate = wxPyBeginAllowThreads();
43275 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43276 wxPyEndAllowThreads(__tstate);
43277 if (PyErr_Occurred()) SWIG_fail;
43278 }
43279 resultobj = SWIG_Py_Void();
43280 return resultobj;
43281 fail:
43282 return NULL;
43283 }
43284
43285
43286 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43287 PyObject *resultobj = 0;
43288 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43289 wxColour result;
43290 void *argp1 = 0 ;
43291 int res1 = 0 ;
43292 PyObject *swig_obj[1] ;
43293
43294 if (!args) SWIG_fail;
43295 swig_obj[0] = args;
43296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43297 if (!SWIG_IsOK(res1)) {
43298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43299 }
43300 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43301 {
43302 PyThreadState* __tstate = wxPyBeginAllowThreads();
43303 result = wxMenuItem_GetBackgroundColour(arg1);
43304 wxPyEndAllowThreads(__tstate);
43305 if (PyErr_Occurred()) SWIG_fail;
43306 }
43307 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43308 return resultobj;
43309 fail:
43310 return NULL;
43311 }
43312
43313
43314 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43315 PyObject *resultobj = 0;
43316 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43317 wxBitmap *arg2 = 0 ;
43318 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43319 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43320 void *argp1 = 0 ;
43321 int res1 = 0 ;
43322 void *argp2 = 0 ;
43323 int res2 = 0 ;
43324 void *argp3 = 0 ;
43325 int res3 = 0 ;
43326 PyObject * obj0 = 0 ;
43327 PyObject * obj1 = 0 ;
43328 PyObject * obj2 = 0 ;
43329 char * kwnames[] = {
43330 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43331 };
43332
43333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43335 if (!SWIG_IsOK(res1)) {
43336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43337 }
43338 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43339 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43340 if (!SWIG_IsOK(res2)) {
43341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43342 }
43343 if (!argp2) {
43344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43345 }
43346 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43347 if (obj2) {
43348 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43349 if (!SWIG_IsOK(res3)) {
43350 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43351 }
43352 if (!argp3) {
43353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43354 }
43355 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43356 }
43357 {
43358 PyThreadState* __tstate = wxPyBeginAllowThreads();
43359 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43360 wxPyEndAllowThreads(__tstate);
43361 if (PyErr_Occurred()) SWIG_fail;
43362 }
43363 resultobj = SWIG_Py_Void();
43364 return resultobj;
43365 fail:
43366 return NULL;
43367 }
43368
43369
43370 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43371 PyObject *resultobj = 0;
43372 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43373 wxBitmap *arg2 = 0 ;
43374 void *argp1 = 0 ;
43375 int res1 = 0 ;
43376 void *argp2 = 0 ;
43377 int res2 = 0 ;
43378 PyObject * obj0 = 0 ;
43379 PyObject * obj1 = 0 ;
43380 char * kwnames[] = {
43381 (char *) "self",(char *) "bmpDisabled", NULL
43382 };
43383
43384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43386 if (!SWIG_IsOK(res1)) {
43387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43388 }
43389 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43390 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43391 if (!SWIG_IsOK(res2)) {
43392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43393 }
43394 if (!argp2) {
43395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43396 }
43397 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43398 {
43399 PyThreadState* __tstate = wxPyBeginAllowThreads();
43400 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43401 wxPyEndAllowThreads(__tstate);
43402 if (PyErr_Occurred()) SWIG_fail;
43403 }
43404 resultobj = SWIG_Py_Void();
43405 return resultobj;
43406 fail:
43407 return NULL;
43408 }
43409
43410
43411 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43412 PyObject *resultobj = 0;
43413 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43414 wxBitmap *result = 0 ;
43415 void *argp1 = 0 ;
43416 int res1 = 0 ;
43417 PyObject *swig_obj[1] ;
43418
43419 if (!args) SWIG_fail;
43420 swig_obj[0] = args;
43421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43422 if (!SWIG_IsOK(res1)) {
43423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43424 }
43425 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43426 {
43427 PyThreadState* __tstate = wxPyBeginAllowThreads();
43428 {
43429 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43430 result = (wxBitmap *) &_result_ref;
43431 }
43432 wxPyEndAllowThreads(__tstate);
43433 if (PyErr_Occurred()) SWIG_fail;
43434 }
43435 {
43436 wxBitmap* resultptr = new wxBitmap(*result);
43437 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43438 }
43439 return resultobj;
43440 fail:
43441 return NULL;
43442 }
43443
43444
43445 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43446 PyObject *resultobj = 0;
43447 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43448 int arg2 ;
43449 void *argp1 = 0 ;
43450 int res1 = 0 ;
43451 int val2 ;
43452 int ecode2 = 0 ;
43453 PyObject * obj0 = 0 ;
43454 PyObject * obj1 = 0 ;
43455 char * kwnames[] = {
43456 (char *) "self",(char *) "nWidth", NULL
43457 };
43458
43459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43461 if (!SWIG_IsOK(res1)) {
43462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43463 }
43464 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43465 ecode2 = SWIG_AsVal_int(obj1, &val2);
43466 if (!SWIG_IsOK(ecode2)) {
43467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43468 }
43469 arg2 = static_cast< int >(val2);
43470 {
43471 PyThreadState* __tstate = wxPyBeginAllowThreads();
43472 wxMenuItem_SetMarginWidth(arg1,arg2);
43473 wxPyEndAllowThreads(__tstate);
43474 if (PyErr_Occurred()) SWIG_fail;
43475 }
43476 resultobj = SWIG_Py_Void();
43477 return resultobj;
43478 fail:
43479 return NULL;
43480 }
43481
43482
43483 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43484 PyObject *resultobj = 0;
43485 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43486 int result;
43487 void *argp1 = 0 ;
43488 int res1 = 0 ;
43489 PyObject *swig_obj[1] ;
43490
43491 if (!args) SWIG_fail;
43492 swig_obj[0] = args;
43493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43494 if (!SWIG_IsOK(res1)) {
43495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43496 }
43497 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43498 {
43499 PyThreadState* __tstate = wxPyBeginAllowThreads();
43500 result = (int)wxMenuItem_GetMarginWidth(arg1);
43501 wxPyEndAllowThreads(__tstate);
43502 if (PyErr_Occurred()) SWIG_fail;
43503 }
43504 resultobj = SWIG_From_int(static_cast< int >(result));
43505 return resultobj;
43506 fail:
43507 return NULL;
43508 }
43509
43510
43511 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43512 PyObject *resultobj = 0;
43513 int result;
43514
43515 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43516 {
43517 PyThreadState* __tstate = wxPyBeginAllowThreads();
43518 result = (int)wxMenuItem_GetDefaultMarginWidth();
43519 wxPyEndAllowThreads(__tstate);
43520 if (PyErr_Occurred()) SWIG_fail;
43521 }
43522 resultobj = SWIG_From_int(static_cast< int >(result));
43523 return resultobj;
43524 fail:
43525 return NULL;
43526 }
43527
43528
43529 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43530 PyObject *resultobj = 0;
43531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43532 bool result;
43533 void *argp1 = 0 ;
43534 int res1 = 0 ;
43535 PyObject *swig_obj[1] ;
43536
43537 if (!args) SWIG_fail;
43538 swig_obj[0] = args;
43539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43540 if (!SWIG_IsOK(res1)) {
43541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43542 }
43543 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43544 {
43545 PyThreadState* __tstate = wxPyBeginAllowThreads();
43546 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43547 wxPyEndAllowThreads(__tstate);
43548 if (PyErr_Occurred()) SWIG_fail;
43549 }
43550 {
43551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43552 }
43553 return resultobj;
43554 fail:
43555 return NULL;
43556 }
43557
43558
43559 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43560 PyObject *resultobj = 0;
43561 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43562 bool arg2 = (bool) true ;
43563 void *argp1 = 0 ;
43564 int res1 = 0 ;
43565 bool val2 ;
43566 int ecode2 = 0 ;
43567 PyObject * obj0 = 0 ;
43568 PyObject * obj1 = 0 ;
43569 char * kwnames[] = {
43570 (char *) "self",(char *) "ownerDrawn", NULL
43571 };
43572
43573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43575 if (!SWIG_IsOK(res1)) {
43576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43577 }
43578 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43579 if (obj1) {
43580 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43581 if (!SWIG_IsOK(ecode2)) {
43582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43583 }
43584 arg2 = static_cast< bool >(val2);
43585 }
43586 {
43587 PyThreadState* __tstate = wxPyBeginAllowThreads();
43588 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43589 wxPyEndAllowThreads(__tstate);
43590 if (PyErr_Occurred()) SWIG_fail;
43591 }
43592 resultobj = SWIG_Py_Void();
43593 return resultobj;
43594 fail:
43595 return NULL;
43596 }
43597
43598
43599 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43600 PyObject *resultobj = 0;
43601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
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_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43611 }
43612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43613 {
43614 PyThreadState* __tstate = wxPyBeginAllowThreads();
43615 wxMenuItem_ResetOwnerDrawn(arg1);
43616 wxPyEndAllowThreads(__tstate);
43617 if (PyErr_Occurred()) SWIG_fail;
43618 }
43619 resultobj = SWIG_Py_Void();
43620 return resultobj;
43621 fail:
43622 return NULL;
43623 }
43624
43625
43626 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43627 PyObject *obj;
43628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43629 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43630 return SWIG_Py_Void();
43631 }
43632
43633 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43634 return SWIG_Python_InitShadowInstance(args);
43635 }
43636
43637 SWIGINTERN int ControlNameStr_set(PyObject *) {
43638 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43639 return 1;
43640 }
43641
43642
43643 SWIGINTERN PyObject *ControlNameStr_get(void) {
43644 PyObject *pyobj = 0;
43645
43646 {
43647 #if wxUSE_UNICODE
43648 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43649 #else
43650 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43651 #endif
43652 }
43653 return pyobj;
43654 }
43655
43656
43657 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43658 PyObject *resultobj = 0;
43659 wxWindow *arg1 = (wxWindow *) 0 ;
43660 int arg2 = (int) -1 ;
43661 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43662 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43663 wxSize const &arg4_defvalue = wxDefaultSize ;
43664 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43665 long arg5 = (long) 0 ;
43666 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43667 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43668 wxString const &arg7_defvalue = wxPyControlNameStr ;
43669 wxString *arg7 = (wxString *) &arg7_defvalue ;
43670 wxControl *result = 0 ;
43671 void *argp1 = 0 ;
43672 int res1 = 0 ;
43673 int val2 ;
43674 int ecode2 = 0 ;
43675 wxPoint temp3 ;
43676 wxSize temp4 ;
43677 long val5 ;
43678 int ecode5 = 0 ;
43679 void *argp6 = 0 ;
43680 int res6 = 0 ;
43681 bool temp7 = false ;
43682 PyObject * obj0 = 0 ;
43683 PyObject * obj1 = 0 ;
43684 PyObject * obj2 = 0 ;
43685 PyObject * obj3 = 0 ;
43686 PyObject * obj4 = 0 ;
43687 PyObject * obj5 = 0 ;
43688 PyObject * obj6 = 0 ;
43689 char * kwnames[] = {
43690 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43691 };
43692
43693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43695 if (!SWIG_IsOK(res1)) {
43696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43697 }
43698 arg1 = reinterpret_cast< wxWindow * >(argp1);
43699 if (obj1) {
43700 ecode2 = SWIG_AsVal_int(obj1, &val2);
43701 if (!SWIG_IsOK(ecode2)) {
43702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43703 }
43704 arg2 = static_cast< int >(val2);
43705 }
43706 if (obj2) {
43707 {
43708 arg3 = &temp3;
43709 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43710 }
43711 }
43712 if (obj3) {
43713 {
43714 arg4 = &temp4;
43715 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43716 }
43717 }
43718 if (obj4) {
43719 ecode5 = SWIG_AsVal_long(obj4, &val5);
43720 if (!SWIG_IsOK(ecode5)) {
43721 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43722 }
43723 arg5 = static_cast< long >(val5);
43724 }
43725 if (obj5) {
43726 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43727 if (!SWIG_IsOK(res6)) {
43728 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43729 }
43730 if (!argp6) {
43731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43732 }
43733 arg6 = reinterpret_cast< wxValidator * >(argp6);
43734 }
43735 if (obj6) {
43736 {
43737 arg7 = wxString_in_helper(obj6);
43738 if (arg7 == NULL) SWIG_fail;
43739 temp7 = true;
43740 }
43741 }
43742 {
43743 if (!wxPyCheckForApp()) SWIG_fail;
43744 PyThreadState* __tstate = wxPyBeginAllowThreads();
43745 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43746 wxPyEndAllowThreads(__tstate);
43747 if (PyErr_Occurred()) SWIG_fail;
43748 }
43749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43750 {
43751 if (temp7)
43752 delete arg7;
43753 }
43754 return resultobj;
43755 fail:
43756 {
43757 if (temp7)
43758 delete arg7;
43759 }
43760 return NULL;
43761 }
43762
43763
43764 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43765 PyObject *resultobj = 0;
43766 wxControl *result = 0 ;
43767
43768 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43769 {
43770 if (!wxPyCheckForApp()) SWIG_fail;
43771 PyThreadState* __tstate = wxPyBeginAllowThreads();
43772 result = (wxControl *)new wxControl();
43773 wxPyEndAllowThreads(__tstate);
43774 if (PyErr_Occurred()) SWIG_fail;
43775 }
43776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43777 return resultobj;
43778 fail:
43779 return NULL;
43780 }
43781
43782
43783 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43784 PyObject *resultobj = 0;
43785 wxControl *arg1 = (wxControl *) 0 ;
43786 wxWindow *arg2 = (wxWindow *) 0 ;
43787 int arg3 = (int) -1 ;
43788 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43789 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43790 wxSize const &arg5_defvalue = wxDefaultSize ;
43791 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43792 long arg6 = (long) 0 ;
43793 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43794 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43795 wxString const &arg8_defvalue = wxPyControlNameStr ;
43796 wxString *arg8 = (wxString *) &arg8_defvalue ;
43797 bool result;
43798 void *argp1 = 0 ;
43799 int res1 = 0 ;
43800 void *argp2 = 0 ;
43801 int res2 = 0 ;
43802 int val3 ;
43803 int ecode3 = 0 ;
43804 wxPoint temp4 ;
43805 wxSize temp5 ;
43806 long val6 ;
43807 int ecode6 = 0 ;
43808 void *argp7 = 0 ;
43809 int res7 = 0 ;
43810 bool temp8 = false ;
43811 PyObject * obj0 = 0 ;
43812 PyObject * obj1 = 0 ;
43813 PyObject * obj2 = 0 ;
43814 PyObject * obj3 = 0 ;
43815 PyObject * obj4 = 0 ;
43816 PyObject * obj5 = 0 ;
43817 PyObject * obj6 = 0 ;
43818 PyObject * obj7 = 0 ;
43819 char * kwnames[] = {
43820 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43821 };
43822
43823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43825 if (!SWIG_IsOK(res1)) {
43826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43827 }
43828 arg1 = reinterpret_cast< wxControl * >(argp1);
43829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43830 if (!SWIG_IsOK(res2)) {
43831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43832 }
43833 arg2 = reinterpret_cast< wxWindow * >(argp2);
43834 if (obj2) {
43835 ecode3 = SWIG_AsVal_int(obj2, &val3);
43836 if (!SWIG_IsOK(ecode3)) {
43837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43838 }
43839 arg3 = static_cast< int >(val3);
43840 }
43841 if (obj3) {
43842 {
43843 arg4 = &temp4;
43844 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43845 }
43846 }
43847 if (obj4) {
43848 {
43849 arg5 = &temp5;
43850 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43851 }
43852 }
43853 if (obj5) {
43854 ecode6 = SWIG_AsVal_long(obj5, &val6);
43855 if (!SWIG_IsOK(ecode6)) {
43856 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43857 }
43858 arg6 = static_cast< long >(val6);
43859 }
43860 if (obj6) {
43861 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43862 if (!SWIG_IsOK(res7)) {
43863 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43864 }
43865 if (!argp7) {
43866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43867 }
43868 arg7 = reinterpret_cast< wxValidator * >(argp7);
43869 }
43870 if (obj7) {
43871 {
43872 arg8 = wxString_in_helper(obj7);
43873 if (arg8 == NULL) SWIG_fail;
43874 temp8 = true;
43875 }
43876 }
43877 {
43878 PyThreadState* __tstate = wxPyBeginAllowThreads();
43879 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43880 wxPyEndAllowThreads(__tstate);
43881 if (PyErr_Occurred()) SWIG_fail;
43882 }
43883 {
43884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43885 }
43886 {
43887 if (temp8)
43888 delete arg8;
43889 }
43890 return resultobj;
43891 fail:
43892 {
43893 if (temp8)
43894 delete arg8;
43895 }
43896 return NULL;
43897 }
43898
43899
43900 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43901 PyObject *resultobj = 0;
43902 wxControl *arg1 = (wxControl *) 0 ;
43903 wxCommandEvent *arg2 = 0 ;
43904 void *argp1 = 0 ;
43905 int res1 = 0 ;
43906 void *argp2 = 0 ;
43907 int res2 = 0 ;
43908 PyObject * obj0 = 0 ;
43909 PyObject * obj1 = 0 ;
43910 char * kwnames[] = {
43911 (char *) "self",(char *) "event", NULL
43912 };
43913
43914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43916 if (!SWIG_IsOK(res1)) {
43917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43918 }
43919 arg1 = reinterpret_cast< wxControl * >(argp1);
43920 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43921 if (!SWIG_IsOK(res2)) {
43922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43923 }
43924 if (!argp2) {
43925 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43926 }
43927 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43928 {
43929 PyThreadState* __tstate = wxPyBeginAllowThreads();
43930 (arg1)->Command(*arg2);
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 resultobj = SWIG_Py_Void();
43935 return resultobj;
43936 fail:
43937 return NULL;
43938 }
43939
43940
43941 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43942 PyObject *resultobj = 0;
43943 wxControl *arg1 = (wxControl *) 0 ;
43944 wxString result;
43945 void *argp1 = 0 ;
43946 int res1 = 0 ;
43947 PyObject *swig_obj[1] ;
43948
43949 if (!args) SWIG_fail;
43950 swig_obj[0] = args;
43951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43952 if (!SWIG_IsOK(res1)) {
43953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43954 }
43955 arg1 = reinterpret_cast< wxControl * >(argp1);
43956 {
43957 PyThreadState* __tstate = wxPyBeginAllowThreads();
43958 result = (arg1)->GetLabel();
43959 wxPyEndAllowThreads(__tstate);
43960 if (PyErr_Occurred()) SWIG_fail;
43961 }
43962 {
43963 #if wxUSE_UNICODE
43964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43965 #else
43966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43967 #endif
43968 }
43969 return resultobj;
43970 fail:
43971 return NULL;
43972 }
43973
43974
43975 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43976 PyObject *resultobj = 0;
43977 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43978 SwigValueWrapper<wxVisualAttributes > result;
43979 int val1 ;
43980 int ecode1 = 0 ;
43981 PyObject * obj0 = 0 ;
43982 char * kwnames[] = {
43983 (char *) "variant", NULL
43984 };
43985
43986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43987 if (obj0) {
43988 ecode1 = SWIG_AsVal_int(obj0, &val1);
43989 if (!SWIG_IsOK(ecode1)) {
43990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43991 }
43992 arg1 = static_cast< wxWindowVariant >(val1);
43993 }
43994 {
43995 if (!wxPyCheckForApp()) SWIG_fail;
43996 PyThreadState* __tstate = wxPyBeginAllowThreads();
43997 result = wxControl::GetClassDefaultAttributes(arg1);
43998 wxPyEndAllowThreads(__tstate);
43999 if (PyErr_Occurred()) SWIG_fail;
44000 }
44001 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44002 return resultobj;
44003 fail:
44004 return NULL;
44005 }
44006
44007
44008 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44009 PyObject *obj;
44010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44011 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44012 return SWIG_Py_Void();
44013 }
44014
44015 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44016 return SWIG_Python_InitShadowInstance(args);
44017 }
44018
44019 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44020 PyObject *resultobj = 0;
44021 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44022 wxString *arg2 = 0 ;
44023 PyObject *arg3 = (PyObject *) NULL ;
44024 int result;
44025 void *argp1 = 0 ;
44026 int res1 = 0 ;
44027 bool temp2 = false ;
44028 PyObject * obj0 = 0 ;
44029 PyObject * obj1 = 0 ;
44030 PyObject * obj2 = 0 ;
44031 char * kwnames[] = {
44032 (char *) "self",(char *) "item",(char *) "clientData", NULL
44033 };
44034
44035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44037 if (!SWIG_IsOK(res1)) {
44038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44039 }
44040 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44041 {
44042 arg2 = wxString_in_helper(obj1);
44043 if (arg2 == NULL) SWIG_fail;
44044 temp2 = true;
44045 }
44046 if (obj2) {
44047 arg3 = obj2;
44048 }
44049 {
44050 PyThreadState* __tstate = wxPyBeginAllowThreads();
44051 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44052 wxPyEndAllowThreads(__tstate);
44053 if (PyErr_Occurred()) SWIG_fail;
44054 }
44055 resultobj = SWIG_From_int(static_cast< int >(result));
44056 {
44057 if (temp2)
44058 delete arg2;
44059 }
44060 return resultobj;
44061 fail:
44062 {
44063 if (temp2)
44064 delete arg2;
44065 }
44066 return NULL;
44067 }
44068
44069
44070 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44071 PyObject *resultobj = 0;
44072 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44073 wxArrayString *arg2 = 0 ;
44074 void *argp1 = 0 ;
44075 int res1 = 0 ;
44076 bool temp2 = false ;
44077 PyObject * obj0 = 0 ;
44078 PyObject * obj1 = 0 ;
44079 char * kwnames[] = {
44080 (char *) "self",(char *) "strings", NULL
44081 };
44082
44083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44085 if (!SWIG_IsOK(res1)) {
44086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44087 }
44088 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44089 {
44090 if (! PySequence_Check(obj1)) {
44091 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44092 SWIG_fail;
44093 }
44094 arg2 = new wxArrayString;
44095 temp2 = true;
44096 int i, len=PySequence_Length(obj1);
44097 for (i=0; i<len; i++) {
44098 PyObject* item = PySequence_GetItem(obj1, i);
44099 wxString* s = wxString_in_helper(item);
44100 if (PyErr_Occurred()) SWIG_fail;
44101 arg2->Add(*s);
44102 delete s;
44103 Py_DECREF(item);
44104 }
44105 }
44106 {
44107 PyThreadState* __tstate = wxPyBeginAllowThreads();
44108 (arg1)->Append((wxArrayString const &)*arg2);
44109 wxPyEndAllowThreads(__tstate);
44110 if (PyErr_Occurred()) SWIG_fail;
44111 }
44112 resultobj = SWIG_Py_Void();
44113 {
44114 if (temp2) delete arg2;
44115 }
44116 return resultobj;
44117 fail:
44118 {
44119 if (temp2) delete arg2;
44120 }
44121 return NULL;
44122 }
44123
44124
44125 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44126 PyObject *resultobj = 0;
44127 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44128 wxString *arg2 = 0 ;
44129 unsigned int arg3 ;
44130 PyObject *arg4 = (PyObject *) NULL ;
44131 int result;
44132 void *argp1 = 0 ;
44133 int res1 = 0 ;
44134 bool temp2 = false ;
44135 unsigned int val3 ;
44136 int ecode3 = 0 ;
44137 PyObject * obj0 = 0 ;
44138 PyObject * obj1 = 0 ;
44139 PyObject * obj2 = 0 ;
44140 PyObject * obj3 = 0 ;
44141 char * kwnames[] = {
44142 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44143 };
44144
44145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44147 if (!SWIG_IsOK(res1)) {
44148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44149 }
44150 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44151 {
44152 arg2 = wxString_in_helper(obj1);
44153 if (arg2 == NULL) SWIG_fail;
44154 temp2 = true;
44155 }
44156 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44157 if (!SWIG_IsOK(ecode3)) {
44158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44159 }
44160 arg3 = static_cast< unsigned int >(val3);
44161 if (obj3) {
44162 arg4 = obj3;
44163 }
44164 {
44165 PyThreadState* __tstate = wxPyBeginAllowThreads();
44166 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44167 wxPyEndAllowThreads(__tstate);
44168 if (PyErr_Occurred()) SWIG_fail;
44169 }
44170 resultobj = SWIG_From_int(static_cast< int >(result));
44171 {
44172 if (temp2)
44173 delete arg2;
44174 }
44175 return resultobj;
44176 fail:
44177 {
44178 if (temp2)
44179 delete arg2;
44180 }
44181 return NULL;
44182 }
44183
44184
44185 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44186 PyObject *resultobj = 0;
44187 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44188 void *argp1 = 0 ;
44189 int res1 = 0 ;
44190 PyObject *swig_obj[1] ;
44191
44192 if (!args) SWIG_fail;
44193 swig_obj[0] = args;
44194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44195 if (!SWIG_IsOK(res1)) {
44196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44197 }
44198 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44199 {
44200 PyThreadState* __tstate = wxPyBeginAllowThreads();
44201 (arg1)->Clear();
44202 wxPyEndAllowThreads(__tstate);
44203 if (PyErr_Occurred()) SWIG_fail;
44204 }
44205 resultobj = SWIG_Py_Void();
44206 return resultobj;
44207 fail:
44208 return NULL;
44209 }
44210
44211
44212 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44213 PyObject *resultobj = 0;
44214 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44215 unsigned int arg2 ;
44216 void *argp1 = 0 ;
44217 int res1 = 0 ;
44218 unsigned int val2 ;
44219 int ecode2 = 0 ;
44220 PyObject * obj0 = 0 ;
44221 PyObject * obj1 = 0 ;
44222 char * kwnames[] = {
44223 (char *) "self",(char *) "n", NULL
44224 };
44225
44226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44228 if (!SWIG_IsOK(res1)) {
44229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44230 }
44231 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44232 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44233 if (!SWIG_IsOK(ecode2)) {
44234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44235 }
44236 arg2 = static_cast< unsigned int >(val2);
44237 {
44238 PyThreadState* __tstate = wxPyBeginAllowThreads();
44239 (arg1)->Delete(arg2);
44240 wxPyEndAllowThreads(__tstate);
44241 if (PyErr_Occurred()) SWIG_fail;
44242 }
44243 resultobj = SWIG_Py_Void();
44244 return resultobj;
44245 fail:
44246 return NULL;
44247 }
44248
44249
44250 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44251 PyObject *resultobj = 0;
44252 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44253 unsigned int arg2 ;
44254 PyObject *result = 0 ;
44255 void *argp1 = 0 ;
44256 int res1 = 0 ;
44257 unsigned int val2 ;
44258 int ecode2 = 0 ;
44259 PyObject * obj0 = 0 ;
44260 PyObject * obj1 = 0 ;
44261 char * kwnames[] = {
44262 (char *) "self",(char *) "n", NULL
44263 };
44264
44265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44267 if (!SWIG_IsOK(res1)) {
44268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44269 }
44270 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44271 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44272 if (!SWIG_IsOK(ecode2)) {
44273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44274 }
44275 arg2 = static_cast< unsigned int >(val2);
44276 {
44277 PyThreadState* __tstate = wxPyBeginAllowThreads();
44278 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44279 wxPyEndAllowThreads(__tstate);
44280 if (PyErr_Occurred()) SWIG_fail;
44281 }
44282 resultobj = result;
44283 return resultobj;
44284 fail:
44285 return NULL;
44286 }
44287
44288
44289 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44290 PyObject *resultobj = 0;
44291 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44292 unsigned int arg2 ;
44293 PyObject *arg3 = (PyObject *) 0 ;
44294 void *argp1 = 0 ;
44295 int res1 = 0 ;
44296 unsigned int val2 ;
44297 int ecode2 = 0 ;
44298 PyObject * obj0 = 0 ;
44299 PyObject * obj1 = 0 ;
44300 PyObject * obj2 = 0 ;
44301 char * kwnames[] = {
44302 (char *) "self",(char *) "n",(char *) "clientData", NULL
44303 };
44304
44305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44307 if (!SWIG_IsOK(res1)) {
44308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44309 }
44310 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44311 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44312 if (!SWIG_IsOK(ecode2)) {
44313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44314 }
44315 arg2 = static_cast< unsigned int >(val2);
44316 arg3 = obj2;
44317 {
44318 PyThreadState* __tstate = wxPyBeginAllowThreads();
44319 wxItemContainer_SetClientData(arg1,arg2,arg3);
44320 wxPyEndAllowThreads(__tstate);
44321 if (PyErr_Occurred()) SWIG_fail;
44322 }
44323 resultobj = SWIG_Py_Void();
44324 return resultobj;
44325 fail:
44326 return NULL;
44327 }
44328
44329
44330 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44331 PyObject *resultobj = 0;
44332 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44333 unsigned int result;
44334 void *argp1 = 0 ;
44335 int res1 = 0 ;
44336 PyObject *swig_obj[1] ;
44337
44338 if (!args) SWIG_fail;
44339 swig_obj[0] = args;
44340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44341 if (!SWIG_IsOK(res1)) {
44342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44343 }
44344 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44345 {
44346 PyThreadState* __tstate = wxPyBeginAllowThreads();
44347 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44348 wxPyEndAllowThreads(__tstate);
44349 if (PyErr_Occurred()) SWIG_fail;
44350 }
44351 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44352 return resultobj;
44353 fail:
44354 return NULL;
44355 }
44356
44357
44358 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44359 PyObject *resultobj = 0;
44360 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44361 bool result;
44362 void *argp1 = 0 ;
44363 int res1 = 0 ;
44364 PyObject *swig_obj[1] ;
44365
44366 if (!args) SWIG_fail;
44367 swig_obj[0] = args;
44368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44369 if (!SWIG_IsOK(res1)) {
44370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44371 }
44372 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44373 {
44374 PyThreadState* __tstate = wxPyBeginAllowThreads();
44375 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44376 wxPyEndAllowThreads(__tstate);
44377 if (PyErr_Occurred()) SWIG_fail;
44378 }
44379 {
44380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44381 }
44382 return resultobj;
44383 fail:
44384 return NULL;
44385 }
44386
44387
44388 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44389 PyObject *resultobj = 0;
44390 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44391 unsigned int arg2 ;
44392 wxString result;
44393 void *argp1 = 0 ;
44394 int res1 = 0 ;
44395 unsigned int val2 ;
44396 int ecode2 = 0 ;
44397 PyObject * obj0 = 0 ;
44398 PyObject * obj1 = 0 ;
44399 char * kwnames[] = {
44400 (char *) "self",(char *) "n", NULL
44401 };
44402
44403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44405 if (!SWIG_IsOK(res1)) {
44406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44407 }
44408 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44409 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44410 if (!SWIG_IsOK(ecode2)) {
44411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44412 }
44413 arg2 = static_cast< unsigned int >(val2);
44414 {
44415 PyThreadState* __tstate = wxPyBeginAllowThreads();
44416 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44417 wxPyEndAllowThreads(__tstate);
44418 if (PyErr_Occurred()) SWIG_fail;
44419 }
44420 {
44421 #if wxUSE_UNICODE
44422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44423 #else
44424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44425 #endif
44426 }
44427 return resultobj;
44428 fail:
44429 return NULL;
44430 }
44431
44432
44433 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44434 PyObject *resultobj = 0;
44435 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44436 wxArrayString result;
44437 void *argp1 = 0 ;
44438 int res1 = 0 ;
44439 PyObject *swig_obj[1] ;
44440
44441 if (!args) SWIG_fail;
44442 swig_obj[0] = args;
44443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44444 if (!SWIG_IsOK(res1)) {
44445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44446 }
44447 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44448 {
44449 PyThreadState* __tstate = wxPyBeginAllowThreads();
44450 result = ((wxItemContainer const *)arg1)->GetStrings();
44451 wxPyEndAllowThreads(__tstate);
44452 if (PyErr_Occurred()) SWIG_fail;
44453 }
44454 {
44455 resultobj = wxArrayString2PyList_helper(result);
44456 }
44457 return resultobj;
44458 fail:
44459 return NULL;
44460 }
44461
44462
44463 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44464 PyObject *resultobj = 0;
44465 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44466 unsigned int arg2 ;
44467 wxString *arg3 = 0 ;
44468 void *argp1 = 0 ;
44469 int res1 = 0 ;
44470 unsigned int val2 ;
44471 int ecode2 = 0 ;
44472 bool temp3 = false ;
44473 PyObject * obj0 = 0 ;
44474 PyObject * obj1 = 0 ;
44475 PyObject * obj2 = 0 ;
44476 char * kwnames[] = {
44477 (char *) "self",(char *) "n",(char *) "s", NULL
44478 };
44479
44480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44482 if (!SWIG_IsOK(res1)) {
44483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44484 }
44485 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44486 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44487 if (!SWIG_IsOK(ecode2)) {
44488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44489 }
44490 arg2 = static_cast< unsigned int >(val2);
44491 {
44492 arg3 = wxString_in_helper(obj2);
44493 if (arg3 == NULL) SWIG_fail;
44494 temp3 = true;
44495 }
44496 {
44497 PyThreadState* __tstate = wxPyBeginAllowThreads();
44498 (arg1)->SetString(arg2,(wxString const &)*arg3);
44499 wxPyEndAllowThreads(__tstate);
44500 if (PyErr_Occurred()) SWIG_fail;
44501 }
44502 resultobj = SWIG_Py_Void();
44503 {
44504 if (temp3)
44505 delete arg3;
44506 }
44507 return resultobj;
44508 fail:
44509 {
44510 if (temp3)
44511 delete arg3;
44512 }
44513 return NULL;
44514 }
44515
44516
44517 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44518 PyObject *resultobj = 0;
44519 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44520 wxString *arg2 = 0 ;
44521 int result;
44522 void *argp1 = 0 ;
44523 int res1 = 0 ;
44524 bool temp2 = false ;
44525 PyObject * obj0 = 0 ;
44526 PyObject * obj1 = 0 ;
44527 char * kwnames[] = {
44528 (char *) "self",(char *) "s", NULL
44529 };
44530
44531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44533 if (!SWIG_IsOK(res1)) {
44534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44535 }
44536 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44537 {
44538 arg2 = wxString_in_helper(obj1);
44539 if (arg2 == NULL) SWIG_fail;
44540 temp2 = true;
44541 }
44542 {
44543 PyThreadState* __tstate = wxPyBeginAllowThreads();
44544 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44545 wxPyEndAllowThreads(__tstate);
44546 if (PyErr_Occurred()) SWIG_fail;
44547 }
44548 resultobj = SWIG_From_int(static_cast< int >(result));
44549 {
44550 if (temp2)
44551 delete arg2;
44552 }
44553 return resultobj;
44554 fail:
44555 {
44556 if (temp2)
44557 delete arg2;
44558 }
44559 return NULL;
44560 }
44561
44562
44563 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44564 PyObject *resultobj = 0;
44565 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44566 int arg2 ;
44567 void *argp1 = 0 ;
44568 int res1 = 0 ;
44569 int val2 ;
44570 int ecode2 = 0 ;
44571 PyObject * obj0 = 0 ;
44572 PyObject * obj1 = 0 ;
44573 char * kwnames[] = {
44574 (char *) "self",(char *) "n", NULL
44575 };
44576
44577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44579 if (!SWIG_IsOK(res1)) {
44580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44581 }
44582 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44583 ecode2 = SWIG_AsVal_int(obj1, &val2);
44584 if (!SWIG_IsOK(ecode2)) {
44585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44586 }
44587 arg2 = static_cast< int >(val2);
44588 {
44589 PyThreadState* __tstate = wxPyBeginAllowThreads();
44590 (arg1)->SetSelection(arg2);
44591 wxPyEndAllowThreads(__tstate);
44592 if (PyErr_Occurred()) SWIG_fail;
44593 }
44594 resultobj = SWIG_Py_Void();
44595 return resultobj;
44596 fail:
44597 return NULL;
44598 }
44599
44600
44601 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44602 PyObject *resultobj = 0;
44603 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44604 int result;
44605 void *argp1 = 0 ;
44606 int res1 = 0 ;
44607 PyObject *swig_obj[1] ;
44608
44609 if (!args) SWIG_fail;
44610 swig_obj[0] = args;
44611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44612 if (!SWIG_IsOK(res1)) {
44613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44614 }
44615 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44616 {
44617 PyThreadState* __tstate = wxPyBeginAllowThreads();
44618 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44619 wxPyEndAllowThreads(__tstate);
44620 if (PyErr_Occurred()) SWIG_fail;
44621 }
44622 resultobj = SWIG_From_int(static_cast< int >(result));
44623 return resultobj;
44624 fail:
44625 return NULL;
44626 }
44627
44628
44629 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44630 PyObject *resultobj = 0;
44631 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44632 wxString *arg2 = 0 ;
44633 bool result;
44634 void *argp1 = 0 ;
44635 int res1 = 0 ;
44636 bool temp2 = false ;
44637 PyObject * obj0 = 0 ;
44638 PyObject * obj1 = 0 ;
44639 char * kwnames[] = {
44640 (char *) "self",(char *) "s", NULL
44641 };
44642
44643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44645 if (!SWIG_IsOK(res1)) {
44646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44647 }
44648 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44649 {
44650 arg2 = wxString_in_helper(obj1);
44651 if (arg2 == NULL) SWIG_fail;
44652 temp2 = true;
44653 }
44654 {
44655 PyThreadState* __tstate = wxPyBeginAllowThreads();
44656 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44657 wxPyEndAllowThreads(__tstate);
44658 if (PyErr_Occurred()) SWIG_fail;
44659 }
44660 {
44661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44662 }
44663 {
44664 if (temp2)
44665 delete arg2;
44666 }
44667 return resultobj;
44668 fail:
44669 {
44670 if (temp2)
44671 delete arg2;
44672 }
44673 return NULL;
44674 }
44675
44676
44677 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44678 PyObject *resultobj = 0;
44679 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44680 wxString result;
44681 void *argp1 = 0 ;
44682 int res1 = 0 ;
44683 PyObject *swig_obj[1] ;
44684
44685 if (!args) SWIG_fail;
44686 swig_obj[0] = args;
44687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44688 if (!SWIG_IsOK(res1)) {
44689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44690 }
44691 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44692 {
44693 PyThreadState* __tstate = wxPyBeginAllowThreads();
44694 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44695 wxPyEndAllowThreads(__tstate);
44696 if (PyErr_Occurred()) SWIG_fail;
44697 }
44698 {
44699 #if wxUSE_UNICODE
44700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44701 #else
44702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44703 #endif
44704 }
44705 return resultobj;
44706 fail:
44707 return NULL;
44708 }
44709
44710
44711 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44712 PyObject *resultobj = 0;
44713 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44714 int arg2 ;
44715 void *argp1 = 0 ;
44716 int res1 = 0 ;
44717 int val2 ;
44718 int ecode2 = 0 ;
44719 PyObject * obj0 = 0 ;
44720 PyObject * obj1 = 0 ;
44721 char * kwnames[] = {
44722 (char *) "self",(char *) "n", NULL
44723 };
44724
44725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44727 if (!SWIG_IsOK(res1)) {
44728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44729 }
44730 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44731 ecode2 = SWIG_AsVal_int(obj1, &val2);
44732 if (!SWIG_IsOK(ecode2)) {
44733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44734 }
44735 arg2 = static_cast< int >(val2);
44736 {
44737 PyThreadState* __tstate = wxPyBeginAllowThreads();
44738 (arg1)->Select(arg2);
44739 wxPyEndAllowThreads(__tstate);
44740 if (PyErr_Occurred()) SWIG_fail;
44741 }
44742 resultobj = SWIG_Py_Void();
44743 return resultobj;
44744 fail:
44745 return NULL;
44746 }
44747
44748
44749 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44750 PyObject *obj;
44751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44752 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44753 return SWIG_Py_Void();
44754 }
44755
44756 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44757 PyObject *obj;
44758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44759 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44760 return SWIG_Py_Void();
44761 }
44762
44763 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44764 PyObject *resultobj = 0;
44765 wxSizerItem *result = 0 ;
44766
44767 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44768 {
44769 PyThreadState* __tstate = wxPyBeginAllowThreads();
44770 result = (wxSizerItem *)new wxSizerItem();
44771 wxPyEndAllowThreads(__tstate);
44772 if (PyErr_Occurred()) SWIG_fail;
44773 }
44774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44775 return resultobj;
44776 fail:
44777 return NULL;
44778 }
44779
44780
44781 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44782 PyObject *resultobj = 0;
44783 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44784 void *argp1 = 0 ;
44785 int res1 = 0 ;
44786 PyObject *swig_obj[1] ;
44787
44788 if (!args) SWIG_fail;
44789 swig_obj[0] = args;
44790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44791 if (!SWIG_IsOK(res1)) {
44792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44793 }
44794 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44795 {
44796 PyThreadState* __tstate = wxPyBeginAllowThreads();
44797 delete arg1;
44798
44799 wxPyEndAllowThreads(__tstate);
44800 if (PyErr_Occurred()) SWIG_fail;
44801 }
44802 resultobj = SWIG_Py_Void();
44803 return resultobj;
44804 fail:
44805 return NULL;
44806 }
44807
44808
44809 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44810 PyObject *resultobj = 0;
44811 wxWindow *arg1 = (wxWindow *) 0 ;
44812 int arg2 ;
44813 int arg3 ;
44814 int arg4 ;
44815 PyObject *arg5 = (PyObject *) NULL ;
44816 wxSizerItem *result = 0 ;
44817 void *argp1 = 0 ;
44818 int res1 = 0 ;
44819 int val2 ;
44820 int ecode2 = 0 ;
44821 int val3 ;
44822 int ecode3 = 0 ;
44823 int val4 ;
44824 int ecode4 = 0 ;
44825 PyObject * obj0 = 0 ;
44826 PyObject * obj1 = 0 ;
44827 PyObject * obj2 = 0 ;
44828 PyObject * obj3 = 0 ;
44829 PyObject * obj4 = 0 ;
44830 char * kwnames[] = {
44831 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44832 };
44833
44834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44836 if (!SWIG_IsOK(res1)) {
44837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44838 }
44839 arg1 = reinterpret_cast< wxWindow * >(argp1);
44840 ecode2 = SWIG_AsVal_int(obj1, &val2);
44841 if (!SWIG_IsOK(ecode2)) {
44842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44843 }
44844 arg2 = static_cast< int >(val2);
44845 ecode3 = SWIG_AsVal_int(obj2, &val3);
44846 if (!SWIG_IsOK(ecode3)) {
44847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44848 }
44849 arg3 = static_cast< int >(val3);
44850 ecode4 = SWIG_AsVal_int(obj3, &val4);
44851 if (!SWIG_IsOK(ecode4)) {
44852 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44853 }
44854 arg4 = static_cast< int >(val4);
44855 if (obj4) {
44856 arg5 = obj4;
44857 }
44858 {
44859 PyThreadState* __tstate = wxPyBeginAllowThreads();
44860 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44861 wxPyEndAllowThreads(__tstate);
44862 if (PyErr_Occurred()) SWIG_fail;
44863 }
44864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44865 return resultobj;
44866 fail:
44867 return NULL;
44868 }
44869
44870
44871 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44872 PyObject *resultobj = 0;
44873 int arg1 ;
44874 int arg2 ;
44875 int arg3 ;
44876 int arg4 ;
44877 int arg5 ;
44878 PyObject *arg6 = (PyObject *) NULL ;
44879 wxSizerItem *result = 0 ;
44880 int val1 ;
44881 int ecode1 = 0 ;
44882 int val2 ;
44883 int ecode2 = 0 ;
44884 int val3 ;
44885 int ecode3 = 0 ;
44886 int val4 ;
44887 int ecode4 = 0 ;
44888 int val5 ;
44889 int ecode5 = 0 ;
44890 PyObject * obj0 = 0 ;
44891 PyObject * obj1 = 0 ;
44892 PyObject * obj2 = 0 ;
44893 PyObject * obj3 = 0 ;
44894 PyObject * obj4 = 0 ;
44895 PyObject * obj5 = 0 ;
44896 char * kwnames[] = {
44897 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44898 };
44899
44900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44901 ecode1 = SWIG_AsVal_int(obj0, &val1);
44902 if (!SWIG_IsOK(ecode1)) {
44903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44904 }
44905 arg1 = static_cast< int >(val1);
44906 ecode2 = SWIG_AsVal_int(obj1, &val2);
44907 if (!SWIG_IsOK(ecode2)) {
44908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44909 }
44910 arg2 = static_cast< int >(val2);
44911 ecode3 = SWIG_AsVal_int(obj2, &val3);
44912 if (!SWIG_IsOK(ecode3)) {
44913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44914 }
44915 arg3 = static_cast< int >(val3);
44916 ecode4 = SWIG_AsVal_int(obj3, &val4);
44917 if (!SWIG_IsOK(ecode4)) {
44918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44919 }
44920 arg4 = static_cast< int >(val4);
44921 ecode5 = SWIG_AsVal_int(obj4, &val5);
44922 if (!SWIG_IsOK(ecode5)) {
44923 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44924 }
44925 arg5 = static_cast< int >(val5);
44926 if (obj5) {
44927 arg6 = obj5;
44928 }
44929 {
44930 PyThreadState* __tstate = wxPyBeginAllowThreads();
44931 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44932 wxPyEndAllowThreads(__tstate);
44933 if (PyErr_Occurred()) SWIG_fail;
44934 }
44935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44936 return resultobj;
44937 fail:
44938 return NULL;
44939 }
44940
44941
44942 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44943 PyObject *resultobj = 0;
44944 wxSizer *arg1 = (wxSizer *) 0 ;
44945 int arg2 ;
44946 int arg3 ;
44947 int arg4 ;
44948 PyObject *arg5 = (PyObject *) NULL ;
44949 wxSizerItem *result = 0 ;
44950 int res1 = 0 ;
44951 int val2 ;
44952 int ecode2 = 0 ;
44953 int val3 ;
44954 int ecode3 = 0 ;
44955 int val4 ;
44956 int ecode4 = 0 ;
44957 PyObject * obj0 = 0 ;
44958 PyObject * obj1 = 0 ;
44959 PyObject * obj2 = 0 ;
44960 PyObject * obj3 = 0 ;
44961 PyObject * obj4 = 0 ;
44962 char * kwnames[] = {
44963 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44964 };
44965
44966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44967 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44968 if (!SWIG_IsOK(res1)) {
44969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44970 }
44971 ecode2 = SWIG_AsVal_int(obj1, &val2);
44972 if (!SWIG_IsOK(ecode2)) {
44973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44974 }
44975 arg2 = static_cast< int >(val2);
44976 ecode3 = SWIG_AsVal_int(obj2, &val3);
44977 if (!SWIG_IsOK(ecode3)) {
44978 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44979 }
44980 arg3 = static_cast< int >(val3);
44981 ecode4 = SWIG_AsVal_int(obj3, &val4);
44982 if (!SWIG_IsOK(ecode4)) {
44983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44984 }
44985 arg4 = static_cast< int >(val4);
44986 if (obj4) {
44987 arg5 = obj4;
44988 }
44989 {
44990 PyThreadState* __tstate = wxPyBeginAllowThreads();
44991 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44992 wxPyEndAllowThreads(__tstate);
44993 if (PyErr_Occurred()) SWIG_fail;
44994 }
44995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44996 return resultobj;
44997 fail:
44998 return NULL;
44999 }
45000
45001
45002 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45003 PyObject *resultobj = 0;
45004 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45005 void *argp1 = 0 ;
45006 int res1 = 0 ;
45007 PyObject *swig_obj[1] ;
45008
45009 if (!args) SWIG_fail;
45010 swig_obj[0] = args;
45011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45012 if (!SWIG_IsOK(res1)) {
45013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45014 }
45015 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45016 {
45017 PyThreadState* __tstate = wxPyBeginAllowThreads();
45018 (arg1)->DeleteWindows();
45019 wxPyEndAllowThreads(__tstate);
45020 if (PyErr_Occurred()) SWIG_fail;
45021 }
45022 resultobj = SWIG_Py_Void();
45023 return resultobj;
45024 fail:
45025 return NULL;
45026 }
45027
45028
45029 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45030 PyObject *resultobj = 0;
45031 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45032 void *argp1 = 0 ;
45033 int res1 = 0 ;
45034 PyObject *swig_obj[1] ;
45035
45036 if (!args) SWIG_fail;
45037 swig_obj[0] = args;
45038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45039 if (!SWIG_IsOK(res1)) {
45040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45041 }
45042 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45043 {
45044 PyThreadState* __tstate = wxPyBeginAllowThreads();
45045 (arg1)->DetachSizer();
45046 wxPyEndAllowThreads(__tstate);
45047 if (PyErr_Occurred()) SWIG_fail;
45048 }
45049 resultobj = SWIG_Py_Void();
45050 return resultobj;
45051 fail:
45052 return NULL;
45053 }
45054
45055
45056 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45057 PyObject *resultobj = 0;
45058 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45059 wxSize result;
45060 void *argp1 = 0 ;
45061 int res1 = 0 ;
45062 PyObject *swig_obj[1] ;
45063
45064 if (!args) SWIG_fail;
45065 swig_obj[0] = args;
45066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45067 if (!SWIG_IsOK(res1)) {
45068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45069 }
45070 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45071 {
45072 PyThreadState* __tstate = wxPyBeginAllowThreads();
45073 result = (arg1)->GetSize();
45074 wxPyEndAllowThreads(__tstate);
45075 if (PyErr_Occurred()) SWIG_fail;
45076 }
45077 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45078 return resultobj;
45079 fail:
45080 return NULL;
45081 }
45082
45083
45084 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45085 PyObject *resultobj = 0;
45086 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45087 wxSize result;
45088 void *argp1 = 0 ;
45089 int res1 = 0 ;
45090 PyObject *swig_obj[1] ;
45091
45092 if (!args) SWIG_fail;
45093 swig_obj[0] = args;
45094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45095 if (!SWIG_IsOK(res1)) {
45096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45097 }
45098 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45099 {
45100 PyThreadState* __tstate = wxPyBeginAllowThreads();
45101 result = (arg1)->CalcMin();
45102 wxPyEndAllowThreads(__tstate);
45103 if (PyErr_Occurred()) SWIG_fail;
45104 }
45105 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45106 return resultobj;
45107 fail:
45108 return NULL;
45109 }
45110
45111
45112 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45113 PyObject *resultobj = 0;
45114 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45115 wxPoint *arg2 = 0 ;
45116 wxSize *arg3 = 0 ;
45117 void *argp1 = 0 ;
45118 int res1 = 0 ;
45119 wxPoint temp2 ;
45120 wxSize temp3 ;
45121 PyObject * obj0 = 0 ;
45122 PyObject * obj1 = 0 ;
45123 PyObject * obj2 = 0 ;
45124 char * kwnames[] = {
45125 (char *) "self",(char *) "pos",(char *) "size", NULL
45126 };
45127
45128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45130 if (!SWIG_IsOK(res1)) {
45131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45132 }
45133 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45134 {
45135 arg2 = &temp2;
45136 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45137 }
45138 {
45139 arg3 = &temp3;
45140 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45141 }
45142 {
45143 PyThreadState* __tstate = wxPyBeginAllowThreads();
45144 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45145 wxPyEndAllowThreads(__tstate);
45146 if (PyErr_Occurred()) SWIG_fail;
45147 }
45148 resultobj = SWIG_Py_Void();
45149 return resultobj;
45150 fail:
45151 return NULL;
45152 }
45153
45154
45155 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45156 PyObject *resultobj = 0;
45157 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45158 wxSize result;
45159 void *argp1 = 0 ;
45160 int res1 = 0 ;
45161 PyObject *swig_obj[1] ;
45162
45163 if (!args) SWIG_fail;
45164 swig_obj[0] = args;
45165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45166 if (!SWIG_IsOK(res1)) {
45167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45168 }
45169 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45170 {
45171 PyThreadState* __tstate = wxPyBeginAllowThreads();
45172 result = (arg1)->GetMinSize();
45173 wxPyEndAllowThreads(__tstate);
45174 if (PyErr_Occurred()) SWIG_fail;
45175 }
45176 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45177 return resultobj;
45178 fail:
45179 return NULL;
45180 }
45181
45182
45183 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45184 PyObject *resultobj = 0;
45185 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45186 wxSize result;
45187 void *argp1 = 0 ;
45188 int res1 = 0 ;
45189 PyObject *swig_obj[1] ;
45190
45191 if (!args) SWIG_fail;
45192 swig_obj[0] = args;
45193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45194 if (!SWIG_IsOK(res1)) {
45195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45196 }
45197 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45198 {
45199 PyThreadState* __tstate = wxPyBeginAllowThreads();
45200 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45201 wxPyEndAllowThreads(__tstate);
45202 if (PyErr_Occurred()) SWIG_fail;
45203 }
45204 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45205 return resultobj;
45206 fail:
45207 return NULL;
45208 }
45209
45210
45211 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45212 PyObject *resultobj = 0;
45213 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45214 int arg2 ;
45215 int arg3 ;
45216 void *argp1 = 0 ;
45217 int res1 = 0 ;
45218 int val2 ;
45219 int ecode2 = 0 ;
45220 int val3 ;
45221 int ecode3 = 0 ;
45222 PyObject * obj0 = 0 ;
45223 PyObject * obj1 = 0 ;
45224 PyObject * obj2 = 0 ;
45225 char * kwnames[] = {
45226 (char *) "self",(char *) "x",(char *) "y", NULL
45227 };
45228
45229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45231 if (!SWIG_IsOK(res1)) {
45232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45233 }
45234 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45235 ecode2 = SWIG_AsVal_int(obj1, &val2);
45236 if (!SWIG_IsOK(ecode2)) {
45237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45238 }
45239 arg2 = static_cast< int >(val2);
45240 ecode3 = SWIG_AsVal_int(obj2, &val3);
45241 if (!SWIG_IsOK(ecode3)) {
45242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45243 }
45244 arg3 = static_cast< int >(val3);
45245 {
45246 PyThreadState* __tstate = wxPyBeginAllowThreads();
45247 (arg1)->SetInitSize(arg2,arg3);
45248 wxPyEndAllowThreads(__tstate);
45249 if (PyErr_Occurred()) SWIG_fail;
45250 }
45251 resultobj = SWIG_Py_Void();
45252 return resultobj;
45253 fail:
45254 return NULL;
45255 }
45256
45257
45258 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45259 PyObject *resultobj = 0;
45260 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45261 int arg2 ;
45262 int arg3 ;
45263 void *argp1 = 0 ;
45264 int res1 = 0 ;
45265 int val2 ;
45266 int ecode2 = 0 ;
45267 int val3 ;
45268 int ecode3 = 0 ;
45269 PyObject * obj0 = 0 ;
45270 PyObject * obj1 = 0 ;
45271 PyObject * obj2 = 0 ;
45272 char * kwnames[] = {
45273 (char *) "self",(char *) "width",(char *) "height", NULL
45274 };
45275
45276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45278 if (!SWIG_IsOK(res1)) {
45279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45280 }
45281 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45282 ecode2 = SWIG_AsVal_int(obj1, &val2);
45283 if (!SWIG_IsOK(ecode2)) {
45284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45285 }
45286 arg2 = static_cast< int >(val2);
45287 ecode3 = SWIG_AsVal_int(obj2, &val3);
45288 if (!SWIG_IsOK(ecode3)) {
45289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45290 }
45291 arg3 = static_cast< int >(val3);
45292 {
45293 PyThreadState* __tstate = wxPyBeginAllowThreads();
45294 (arg1)->SetRatio(arg2,arg3);
45295 wxPyEndAllowThreads(__tstate);
45296 if (PyErr_Occurred()) SWIG_fail;
45297 }
45298 resultobj = SWIG_Py_Void();
45299 return resultobj;
45300 fail:
45301 return NULL;
45302 }
45303
45304
45305 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45306 PyObject *resultobj = 0;
45307 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45308 wxSize *arg2 = 0 ;
45309 void *argp1 = 0 ;
45310 int res1 = 0 ;
45311 wxSize temp2 ;
45312 PyObject * obj0 = 0 ;
45313 PyObject * obj1 = 0 ;
45314 char * kwnames[] = {
45315 (char *) "self",(char *) "size", NULL
45316 };
45317
45318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45320 if (!SWIG_IsOK(res1)) {
45321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45322 }
45323 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45324 {
45325 arg2 = &temp2;
45326 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45327 }
45328 {
45329 PyThreadState* __tstate = wxPyBeginAllowThreads();
45330 (arg1)->SetRatio((wxSize const &)*arg2);
45331 wxPyEndAllowThreads(__tstate);
45332 if (PyErr_Occurred()) SWIG_fail;
45333 }
45334 resultobj = SWIG_Py_Void();
45335 return resultobj;
45336 fail:
45337 return NULL;
45338 }
45339
45340
45341 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45342 PyObject *resultobj = 0;
45343 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45344 float arg2 ;
45345 void *argp1 = 0 ;
45346 int res1 = 0 ;
45347 float val2 ;
45348 int ecode2 = 0 ;
45349 PyObject * obj0 = 0 ;
45350 PyObject * obj1 = 0 ;
45351 char * kwnames[] = {
45352 (char *) "self",(char *) "ratio", NULL
45353 };
45354
45355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45357 if (!SWIG_IsOK(res1)) {
45358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45359 }
45360 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45361 ecode2 = SWIG_AsVal_float(obj1, &val2);
45362 if (!SWIG_IsOK(ecode2)) {
45363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45364 }
45365 arg2 = static_cast< float >(val2);
45366 {
45367 PyThreadState* __tstate = wxPyBeginAllowThreads();
45368 (arg1)->SetRatio(arg2);
45369 wxPyEndAllowThreads(__tstate);
45370 if (PyErr_Occurred()) SWIG_fail;
45371 }
45372 resultobj = SWIG_Py_Void();
45373 return resultobj;
45374 fail:
45375 return NULL;
45376 }
45377
45378
45379 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45380 PyObject *resultobj = 0;
45381 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45382 float result;
45383 void *argp1 = 0 ;
45384 int res1 = 0 ;
45385 PyObject *swig_obj[1] ;
45386
45387 if (!args) SWIG_fail;
45388 swig_obj[0] = args;
45389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45390 if (!SWIG_IsOK(res1)) {
45391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45392 }
45393 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45394 {
45395 PyThreadState* __tstate = wxPyBeginAllowThreads();
45396 result = (float)(arg1)->GetRatio();
45397 wxPyEndAllowThreads(__tstate);
45398 if (PyErr_Occurred()) SWIG_fail;
45399 }
45400 resultobj = SWIG_From_float(static_cast< float >(result));
45401 return resultobj;
45402 fail:
45403 return NULL;
45404 }
45405
45406
45407 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45408 PyObject *resultobj = 0;
45409 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45410 wxRect result;
45411 void *argp1 = 0 ;
45412 int res1 = 0 ;
45413 PyObject *swig_obj[1] ;
45414
45415 if (!args) SWIG_fail;
45416 swig_obj[0] = args;
45417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45418 if (!SWIG_IsOK(res1)) {
45419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45420 }
45421 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45422 {
45423 PyThreadState* __tstate = wxPyBeginAllowThreads();
45424 result = (arg1)->GetRect();
45425 wxPyEndAllowThreads(__tstate);
45426 if (PyErr_Occurred()) SWIG_fail;
45427 }
45428 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45429 return resultobj;
45430 fail:
45431 return NULL;
45432 }
45433
45434
45435 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45436 PyObject *resultobj = 0;
45437 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45438 bool result;
45439 void *argp1 = 0 ;
45440 int res1 = 0 ;
45441 PyObject *swig_obj[1] ;
45442
45443 if (!args) SWIG_fail;
45444 swig_obj[0] = args;
45445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45446 if (!SWIG_IsOK(res1)) {
45447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45448 }
45449 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45450 {
45451 PyThreadState* __tstate = wxPyBeginAllowThreads();
45452 result = (bool)(arg1)->IsWindow();
45453 wxPyEndAllowThreads(__tstate);
45454 if (PyErr_Occurred()) SWIG_fail;
45455 }
45456 {
45457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45458 }
45459 return resultobj;
45460 fail:
45461 return NULL;
45462 }
45463
45464
45465 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45466 PyObject *resultobj = 0;
45467 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45468 bool result;
45469 void *argp1 = 0 ;
45470 int res1 = 0 ;
45471 PyObject *swig_obj[1] ;
45472
45473 if (!args) SWIG_fail;
45474 swig_obj[0] = args;
45475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45476 if (!SWIG_IsOK(res1)) {
45477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45478 }
45479 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45480 {
45481 PyThreadState* __tstate = wxPyBeginAllowThreads();
45482 result = (bool)(arg1)->IsSizer();
45483 wxPyEndAllowThreads(__tstate);
45484 if (PyErr_Occurred()) SWIG_fail;
45485 }
45486 {
45487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45488 }
45489 return resultobj;
45490 fail:
45491 return NULL;
45492 }
45493
45494
45495 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45496 PyObject *resultobj = 0;
45497 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45498 bool result;
45499 void *argp1 = 0 ;
45500 int res1 = 0 ;
45501 PyObject *swig_obj[1] ;
45502
45503 if (!args) SWIG_fail;
45504 swig_obj[0] = args;
45505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45506 if (!SWIG_IsOK(res1)) {
45507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45508 }
45509 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45510 {
45511 PyThreadState* __tstate = wxPyBeginAllowThreads();
45512 result = (bool)(arg1)->IsSpacer();
45513 wxPyEndAllowThreads(__tstate);
45514 if (PyErr_Occurred()) SWIG_fail;
45515 }
45516 {
45517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45518 }
45519 return resultobj;
45520 fail:
45521 return NULL;
45522 }
45523
45524
45525 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45526 PyObject *resultobj = 0;
45527 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45528 int arg2 ;
45529 void *argp1 = 0 ;
45530 int res1 = 0 ;
45531 int val2 ;
45532 int ecode2 = 0 ;
45533 PyObject * obj0 = 0 ;
45534 PyObject * obj1 = 0 ;
45535 char * kwnames[] = {
45536 (char *) "self",(char *) "proportion", NULL
45537 };
45538
45539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45541 if (!SWIG_IsOK(res1)) {
45542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45543 }
45544 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45545 ecode2 = SWIG_AsVal_int(obj1, &val2);
45546 if (!SWIG_IsOK(ecode2)) {
45547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45548 }
45549 arg2 = static_cast< int >(val2);
45550 {
45551 PyThreadState* __tstate = wxPyBeginAllowThreads();
45552 (arg1)->SetProportion(arg2);
45553 wxPyEndAllowThreads(__tstate);
45554 if (PyErr_Occurred()) SWIG_fail;
45555 }
45556 resultobj = SWIG_Py_Void();
45557 return resultobj;
45558 fail:
45559 return NULL;
45560 }
45561
45562
45563 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45564 PyObject *resultobj = 0;
45565 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45566 int result;
45567 void *argp1 = 0 ;
45568 int res1 = 0 ;
45569 PyObject *swig_obj[1] ;
45570
45571 if (!args) SWIG_fail;
45572 swig_obj[0] = args;
45573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45574 if (!SWIG_IsOK(res1)) {
45575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45576 }
45577 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45578 {
45579 PyThreadState* __tstate = wxPyBeginAllowThreads();
45580 result = (int)(arg1)->GetProportion();
45581 wxPyEndAllowThreads(__tstate);
45582 if (PyErr_Occurred()) SWIG_fail;
45583 }
45584 resultobj = SWIG_From_int(static_cast< int >(result));
45585 return resultobj;
45586 fail:
45587 return NULL;
45588 }
45589
45590
45591 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45592 PyObject *resultobj = 0;
45593 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45594 int arg2 ;
45595 void *argp1 = 0 ;
45596 int res1 = 0 ;
45597 int val2 ;
45598 int ecode2 = 0 ;
45599 PyObject * obj0 = 0 ;
45600 PyObject * obj1 = 0 ;
45601 char * kwnames[] = {
45602 (char *) "self",(char *) "flag", NULL
45603 };
45604
45605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45607 if (!SWIG_IsOK(res1)) {
45608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45609 }
45610 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45611 ecode2 = SWIG_AsVal_int(obj1, &val2);
45612 if (!SWIG_IsOK(ecode2)) {
45613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45614 }
45615 arg2 = static_cast< int >(val2);
45616 {
45617 PyThreadState* __tstate = wxPyBeginAllowThreads();
45618 (arg1)->SetFlag(arg2);
45619 wxPyEndAllowThreads(__tstate);
45620 if (PyErr_Occurred()) SWIG_fail;
45621 }
45622 resultobj = SWIG_Py_Void();
45623 return resultobj;
45624 fail:
45625 return NULL;
45626 }
45627
45628
45629 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45630 PyObject *resultobj = 0;
45631 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45632 int result;
45633 void *argp1 = 0 ;
45634 int res1 = 0 ;
45635 PyObject *swig_obj[1] ;
45636
45637 if (!args) SWIG_fail;
45638 swig_obj[0] = args;
45639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45640 if (!SWIG_IsOK(res1)) {
45641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45642 }
45643 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45644 {
45645 PyThreadState* __tstate = wxPyBeginAllowThreads();
45646 result = (int)(arg1)->GetFlag();
45647 wxPyEndAllowThreads(__tstate);
45648 if (PyErr_Occurred()) SWIG_fail;
45649 }
45650 resultobj = SWIG_From_int(static_cast< int >(result));
45651 return resultobj;
45652 fail:
45653 return NULL;
45654 }
45655
45656
45657 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45658 PyObject *resultobj = 0;
45659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45660 int arg2 ;
45661 void *argp1 = 0 ;
45662 int res1 = 0 ;
45663 int val2 ;
45664 int ecode2 = 0 ;
45665 PyObject * obj0 = 0 ;
45666 PyObject * obj1 = 0 ;
45667 char * kwnames[] = {
45668 (char *) "self",(char *) "border", NULL
45669 };
45670
45671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45673 if (!SWIG_IsOK(res1)) {
45674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45675 }
45676 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45677 ecode2 = SWIG_AsVal_int(obj1, &val2);
45678 if (!SWIG_IsOK(ecode2)) {
45679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45680 }
45681 arg2 = static_cast< int >(val2);
45682 {
45683 PyThreadState* __tstate = wxPyBeginAllowThreads();
45684 (arg1)->SetBorder(arg2);
45685 wxPyEndAllowThreads(__tstate);
45686 if (PyErr_Occurred()) SWIG_fail;
45687 }
45688 resultobj = SWIG_Py_Void();
45689 return resultobj;
45690 fail:
45691 return NULL;
45692 }
45693
45694
45695 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45696 PyObject *resultobj = 0;
45697 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45698 int result;
45699 void *argp1 = 0 ;
45700 int res1 = 0 ;
45701 PyObject *swig_obj[1] ;
45702
45703 if (!args) SWIG_fail;
45704 swig_obj[0] = args;
45705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45706 if (!SWIG_IsOK(res1)) {
45707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45708 }
45709 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45710 {
45711 PyThreadState* __tstate = wxPyBeginAllowThreads();
45712 result = (int)(arg1)->GetBorder();
45713 wxPyEndAllowThreads(__tstate);
45714 if (PyErr_Occurred()) SWIG_fail;
45715 }
45716 resultobj = SWIG_From_int(static_cast< int >(result));
45717 return resultobj;
45718 fail:
45719 return NULL;
45720 }
45721
45722
45723 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45724 PyObject *resultobj = 0;
45725 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45726 wxWindow *result = 0 ;
45727 void *argp1 = 0 ;
45728 int res1 = 0 ;
45729 PyObject *swig_obj[1] ;
45730
45731 if (!args) SWIG_fail;
45732 swig_obj[0] = args;
45733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45734 if (!SWIG_IsOK(res1)) {
45735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45736 }
45737 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45738 {
45739 PyThreadState* __tstate = wxPyBeginAllowThreads();
45740 result = (wxWindow *)(arg1)->GetWindow();
45741 wxPyEndAllowThreads(__tstate);
45742 if (PyErr_Occurred()) SWIG_fail;
45743 }
45744 {
45745 resultobj = wxPyMake_wxObject(result, 0);
45746 }
45747 return resultobj;
45748 fail:
45749 return NULL;
45750 }
45751
45752
45753 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45754 PyObject *resultobj = 0;
45755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45756 wxWindow *arg2 = (wxWindow *) 0 ;
45757 void *argp1 = 0 ;
45758 int res1 = 0 ;
45759 void *argp2 = 0 ;
45760 int res2 = 0 ;
45761 PyObject * obj0 = 0 ;
45762 PyObject * obj1 = 0 ;
45763 char * kwnames[] = {
45764 (char *) "self",(char *) "window", NULL
45765 };
45766
45767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45769 if (!SWIG_IsOK(res1)) {
45770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45771 }
45772 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45774 if (!SWIG_IsOK(res2)) {
45775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45776 }
45777 arg2 = reinterpret_cast< wxWindow * >(argp2);
45778 {
45779 PyThreadState* __tstate = wxPyBeginAllowThreads();
45780 (arg1)->SetWindow(arg2);
45781 wxPyEndAllowThreads(__tstate);
45782 if (PyErr_Occurred()) SWIG_fail;
45783 }
45784 resultobj = SWIG_Py_Void();
45785 return resultobj;
45786 fail:
45787 return NULL;
45788 }
45789
45790
45791 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45792 PyObject *resultobj = 0;
45793 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45794 wxSizer *result = 0 ;
45795 void *argp1 = 0 ;
45796 int res1 = 0 ;
45797 PyObject *swig_obj[1] ;
45798
45799 if (!args) SWIG_fail;
45800 swig_obj[0] = args;
45801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45802 if (!SWIG_IsOK(res1)) {
45803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45804 }
45805 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45806 {
45807 PyThreadState* __tstate = wxPyBeginAllowThreads();
45808 result = (wxSizer *)(arg1)->GetSizer();
45809 wxPyEndAllowThreads(__tstate);
45810 if (PyErr_Occurred()) SWIG_fail;
45811 }
45812 {
45813 resultobj = wxPyMake_wxObject(result, (bool)0);
45814 }
45815 return resultobj;
45816 fail:
45817 return NULL;
45818 }
45819
45820
45821 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45822 PyObject *resultobj = 0;
45823 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45824 wxSizer *arg2 = (wxSizer *) 0 ;
45825 void *argp1 = 0 ;
45826 int res1 = 0 ;
45827 int res2 = 0 ;
45828 PyObject * obj0 = 0 ;
45829 PyObject * obj1 = 0 ;
45830 char * kwnames[] = {
45831 (char *) "self",(char *) "sizer", NULL
45832 };
45833
45834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45836 if (!SWIG_IsOK(res1)) {
45837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45838 }
45839 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45840 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45841 if (!SWIG_IsOK(res2)) {
45842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45843 }
45844 {
45845 PyThreadState* __tstate = wxPyBeginAllowThreads();
45846 (arg1)->SetSizer(arg2);
45847 wxPyEndAllowThreads(__tstate);
45848 if (PyErr_Occurred()) SWIG_fail;
45849 }
45850 resultobj = SWIG_Py_Void();
45851 return resultobj;
45852 fail:
45853 return NULL;
45854 }
45855
45856
45857 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45858 PyObject *resultobj = 0;
45859 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45860 wxSize *result = 0 ;
45861 void *argp1 = 0 ;
45862 int res1 = 0 ;
45863 PyObject *swig_obj[1] ;
45864
45865 if (!args) SWIG_fail;
45866 swig_obj[0] = args;
45867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45868 if (!SWIG_IsOK(res1)) {
45869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45870 }
45871 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45872 {
45873 PyThreadState* __tstate = wxPyBeginAllowThreads();
45874 {
45875 wxSize const &_result_ref = (arg1)->GetSpacer();
45876 result = (wxSize *) &_result_ref;
45877 }
45878 wxPyEndAllowThreads(__tstate);
45879 if (PyErr_Occurred()) SWIG_fail;
45880 }
45881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45882 return resultobj;
45883 fail:
45884 return NULL;
45885 }
45886
45887
45888 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45889 PyObject *resultobj = 0;
45890 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45891 wxSize *arg2 = 0 ;
45892 void *argp1 = 0 ;
45893 int res1 = 0 ;
45894 wxSize temp2 ;
45895 PyObject * obj0 = 0 ;
45896 PyObject * obj1 = 0 ;
45897 char * kwnames[] = {
45898 (char *) "self",(char *) "size", NULL
45899 };
45900
45901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45903 if (!SWIG_IsOK(res1)) {
45904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45905 }
45906 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45907 {
45908 arg2 = &temp2;
45909 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45910 }
45911 {
45912 PyThreadState* __tstate = wxPyBeginAllowThreads();
45913 (arg1)->SetSpacer((wxSize const &)*arg2);
45914 wxPyEndAllowThreads(__tstate);
45915 if (PyErr_Occurred()) SWIG_fail;
45916 }
45917 resultobj = SWIG_Py_Void();
45918 return resultobj;
45919 fail:
45920 return NULL;
45921 }
45922
45923
45924 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45925 PyObject *resultobj = 0;
45926 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45927 bool arg2 ;
45928 void *argp1 = 0 ;
45929 int res1 = 0 ;
45930 bool val2 ;
45931 int ecode2 = 0 ;
45932 PyObject * obj0 = 0 ;
45933 PyObject * obj1 = 0 ;
45934 char * kwnames[] = {
45935 (char *) "self",(char *) "show", NULL
45936 };
45937
45938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45940 if (!SWIG_IsOK(res1)) {
45941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45942 }
45943 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45944 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45945 if (!SWIG_IsOK(ecode2)) {
45946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45947 }
45948 arg2 = static_cast< bool >(val2);
45949 {
45950 PyThreadState* __tstate = wxPyBeginAllowThreads();
45951 (arg1)->Show(arg2);
45952 wxPyEndAllowThreads(__tstate);
45953 if (PyErr_Occurred()) SWIG_fail;
45954 }
45955 resultobj = SWIG_Py_Void();
45956 return resultobj;
45957 fail:
45958 return NULL;
45959 }
45960
45961
45962 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45963 PyObject *resultobj = 0;
45964 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45965 bool result;
45966 void *argp1 = 0 ;
45967 int res1 = 0 ;
45968 PyObject *swig_obj[1] ;
45969
45970 if (!args) SWIG_fail;
45971 swig_obj[0] = args;
45972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45973 if (!SWIG_IsOK(res1)) {
45974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45975 }
45976 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45977 {
45978 PyThreadState* __tstate = wxPyBeginAllowThreads();
45979 result = (bool)(arg1)->IsShown();
45980 wxPyEndAllowThreads(__tstate);
45981 if (PyErr_Occurred()) SWIG_fail;
45982 }
45983 {
45984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45985 }
45986 return resultobj;
45987 fail:
45988 return NULL;
45989 }
45990
45991
45992 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45993 PyObject *resultobj = 0;
45994 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45995 wxPoint result;
45996 void *argp1 = 0 ;
45997 int res1 = 0 ;
45998 PyObject *swig_obj[1] ;
45999
46000 if (!args) SWIG_fail;
46001 swig_obj[0] = args;
46002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46003 if (!SWIG_IsOK(res1)) {
46004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46005 }
46006 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46007 {
46008 PyThreadState* __tstate = wxPyBeginAllowThreads();
46009 result = (arg1)->GetPosition();
46010 wxPyEndAllowThreads(__tstate);
46011 if (PyErr_Occurred()) SWIG_fail;
46012 }
46013 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46014 return resultobj;
46015 fail:
46016 return NULL;
46017 }
46018
46019
46020 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46021 PyObject *resultobj = 0;
46022 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46023 PyObject *result = 0 ;
46024 void *argp1 = 0 ;
46025 int res1 = 0 ;
46026 PyObject *swig_obj[1] ;
46027
46028 if (!args) SWIG_fail;
46029 swig_obj[0] = args;
46030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46031 if (!SWIG_IsOK(res1)) {
46032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46033 }
46034 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46038 wxPyEndAllowThreads(__tstate);
46039 if (PyErr_Occurred()) SWIG_fail;
46040 }
46041 resultobj = result;
46042 return resultobj;
46043 fail:
46044 return NULL;
46045 }
46046
46047
46048 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46049 PyObject *resultobj = 0;
46050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46051 PyObject *arg2 = (PyObject *) 0 ;
46052 void *argp1 = 0 ;
46053 int res1 = 0 ;
46054 PyObject * obj0 = 0 ;
46055 PyObject * obj1 = 0 ;
46056 char * kwnames[] = {
46057 (char *) "self",(char *) "userData", NULL
46058 };
46059
46060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46062 if (!SWIG_IsOK(res1)) {
46063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46064 }
46065 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46066 arg2 = obj1;
46067 {
46068 PyThreadState* __tstate = wxPyBeginAllowThreads();
46069 wxSizerItem_SetUserData(arg1,arg2);
46070 wxPyEndAllowThreads(__tstate);
46071 if (PyErr_Occurred()) SWIG_fail;
46072 }
46073 resultobj = SWIG_Py_Void();
46074 return resultobj;
46075 fail:
46076 return NULL;
46077 }
46078
46079
46080 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46081 PyObject *obj;
46082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46083 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46084 return SWIG_Py_Void();
46085 }
46086
46087 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46088 return SWIG_Python_InitShadowInstance(args);
46089 }
46090
46091 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46092 PyObject *resultobj = 0;
46093 wxSizer *arg1 = (wxSizer *) 0 ;
46094 void *argp1 = 0 ;
46095 int res1 = 0 ;
46096 PyObject *swig_obj[1] ;
46097
46098 if (!args) SWIG_fail;
46099 swig_obj[0] = args;
46100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46101 if (!SWIG_IsOK(res1)) {
46102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46103 }
46104 arg1 = reinterpret_cast< wxSizer * >(argp1);
46105 {
46106 PyThreadState* __tstate = wxPyBeginAllowThreads();
46107 delete arg1;
46108
46109 wxPyEndAllowThreads(__tstate);
46110 if (PyErr_Occurred()) SWIG_fail;
46111 }
46112 resultobj = SWIG_Py_Void();
46113 return resultobj;
46114 fail:
46115 return NULL;
46116 }
46117
46118
46119 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46120 PyObject *resultobj = 0;
46121 wxSizer *arg1 = (wxSizer *) 0 ;
46122 PyObject *arg2 = (PyObject *) 0 ;
46123 void *argp1 = 0 ;
46124 int res1 = 0 ;
46125 PyObject * obj0 = 0 ;
46126 PyObject * obj1 = 0 ;
46127 char * kwnames[] = {
46128 (char *) "self",(char *) "_self", NULL
46129 };
46130
46131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46133 if (!SWIG_IsOK(res1)) {
46134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46135 }
46136 arg1 = reinterpret_cast< wxSizer * >(argp1);
46137 arg2 = obj1;
46138 {
46139 PyThreadState* __tstate = wxPyBeginAllowThreads();
46140 wxSizer__setOORInfo(arg1,arg2);
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_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46152 PyObject *resultobj = 0;
46153 wxSizer *arg1 = (wxSizer *) 0 ;
46154 PyObject *arg2 = (PyObject *) 0 ;
46155 int arg3 = (int) 0 ;
46156 int arg4 = (int) 0 ;
46157 int arg5 = (int) 0 ;
46158 PyObject *arg6 = (PyObject *) NULL ;
46159 wxSizerItem *result = 0 ;
46160 void *argp1 = 0 ;
46161 int res1 = 0 ;
46162 int val3 ;
46163 int ecode3 = 0 ;
46164 int val4 ;
46165 int ecode4 = 0 ;
46166 int val5 ;
46167 int ecode5 = 0 ;
46168 PyObject * obj0 = 0 ;
46169 PyObject * obj1 = 0 ;
46170 PyObject * obj2 = 0 ;
46171 PyObject * obj3 = 0 ;
46172 PyObject * obj4 = 0 ;
46173 PyObject * obj5 = 0 ;
46174 char * kwnames[] = {
46175 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46176 };
46177
46178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46180 if (!SWIG_IsOK(res1)) {
46181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46182 }
46183 arg1 = reinterpret_cast< wxSizer * >(argp1);
46184 arg2 = obj1;
46185 if (obj2) {
46186 ecode3 = SWIG_AsVal_int(obj2, &val3);
46187 if (!SWIG_IsOK(ecode3)) {
46188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46189 }
46190 arg3 = static_cast< int >(val3);
46191 }
46192 if (obj3) {
46193 ecode4 = SWIG_AsVal_int(obj3, &val4);
46194 if (!SWIG_IsOK(ecode4)) {
46195 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46196 }
46197 arg4 = static_cast< int >(val4);
46198 }
46199 if (obj4) {
46200 ecode5 = SWIG_AsVal_int(obj4, &val5);
46201 if (!SWIG_IsOK(ecode5)) {
46202 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46203 }
46204 arg5 = static_cast< int >(val5);
46205 }
46206 if (obj5) {
46207 arg6 = obj5;
46208 }
46209 {
46210 PyThreadState* __tstate = wxPyBeginAllowThreads();
46211 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46212 wxPyEndAllowThreads(__tstate);
46213 if (PyErr_Occurred()) SWIG_fail;
46214 }
46215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46216 return resultobj;
46217 fail:
46218 return NULL;
46219 }
46220
46221
46222 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46223 PyObject *resultobj = 0;
46224 wxSizer *arg1 = (wxSizer *) 0 ;
46225 int arg2 ;
46226 PyObject *arg3 = (PyObject *) 0 ;
46227 int arg4 = (int) 0 ;
46228 int arg5 = (int) 0 ;
46229 int arg6 = (int) 0 ;
46230 PyObject *arg7 = (PyObject *) NULL ;
46231 wxSizerItem *result = 0 ;
46232 void *argp1 = 0 ;
46233 int res1 = 0 ;
46234 int val2 ;
46235 int ecode2 = 0 ;
46236 int val4 ;
46237 int ecode4 = 0 ;
46238 int val5 ;
46239 int ecode5 = 0 ;
46240 int val6 ;
46241 int ecode6 = 0 ;
46242 PyObject * obj0 = 0 ;
46243 PyObject * obj1 = 0 ;
46244 PyObject * obj2 = 0 ;
46245 PyObject * obj3 = 0 ;
46246 PyObject * obj4 = 0 ;
46247 PyObject * obj5 = 0 ;
46248 PyObject * obj6 = 0 ;
46249 char * kwnames[] = {
46250 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46251 };
46252
46253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46255 if (!SWIG_IsOK(res1)) {
46256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46257 }
46258 arg1 = reinterpret_cast< wxSizer * >(argp1);
46259 ecode2 = SWIG_AsVal_int(obj1, &val2);
46260 if (!SWIG_IsOK(ecode2)) {
46261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46262 }
46263 arg2 = static_cast< int >(val2);
46264 arg3 = obj2;
46265 if (obj3) {
46266 ecode4 = SWIG_AsVal_int(obj3, &val4);
46267 if (!SWIG_IsOK(ecode4)) {
46268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46269 }
46270 arg4 = static_cast< int >(val4);
46271 }
46272 if (obj4) {
46273 ecode5 = SWIG_AsVal_int(obj4, &val5);
46274 if (!SWIG_IsOK(ecode5)) {
46275 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46276 }
46277 arg5 = static_cast< int >(val5);
46278 }
46279 if (obj5) {
46280 ecode6 = SWIG_AsVal_int(obj5, &val6);
46281 if (!SWIG_IsOK(ecode6)) {
46282 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46283 }
46284 arg6 = static_cast< int >(val6);
46285 }
46286 if (obj6) {
46287 arg7 = obj6;
46288 }
46289 {
46290 PyThreadState* __tstate = wxPyBeginAllowThreads();
46291 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46292 wxPyEndAllowThreads(__tstate);
46293 if (PyErr_Occurred()) SWIG_fail;
46294 }
46295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46296 return resultobj;
46297 fail:
46298 return NULL;
46299 }
46300
46301
46302 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46303 PyObject *resultobj = 0;
46304 wxSizer *arg1 = (wxSizer *) 0 ;
46305 PyObject *arg2 = (PyObject *) 0 ;
46306 int arg3 = (int) 0 ;
46307 int arg4 = (int) 0 ;
46308 int arg5 = (int) 0 ;
46309 PyObject *arg6 = (PyObject *) NULL ;
46310 wxSizerItem *result = 0 ;
46311 void *argp1 = 0 ;
46312 int res1 = 0 ;
46313 int val3 ;
46314 int ecode3 = 0 ;
46315 int val4 ;
46316 int ecode4 = 0 ;
46317 int val5 ;
46318 int ecode5 = 0 ;
46319 PyObject * obj0 = 0 ;
46320 PyObject * obj1 = 0 ;
46321 PyObject * obj2 = 0 ;
46322 PyObject * obj3 = 0 ;
46323 PyObject * obj4 = 0 ;
46324 PyObject * obj5 = 0 ;
46325 char * kwnames[] = {
46326 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46327 };
46328
46329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46331 if (!SWIG_IsOK(res1)) {
46332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46333 }
46334 arg1 = reinterpret_cast< wxSizer * >(argp1);
46335 arg2 = obj1;
46336 if (obj2) {
46337 ecode3 = SWIG_AsVal_int(obj2, &val3);
46338 if (!SWIG_IsOK(ecode3)) {
46339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46340 }
46341 arg3 = static_cast< int >(val3);
46342 }
46343 if (obj3) {
46344 ecode4 = SWIG_AsVal_int(obj3, &val4);
46345 if (!SWIG_IsOK(ecode4)) {
46346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46347 }
46348 arg4 = static_cast< int >(val4);
46349 }
46350 if (obj4) {
46351 ecode5 = SWIG_AsVal_int(obj4, &val5);
46352 if (!SWIG_IsOK(ecode5)) {
46353 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46354 }
46355 arg5 = static_cast< int >(val5);
46356 }
46357 if (obj5) {
46358 arg6 = obj5;
46359 }
46360 {
46361 PyThreadState* __tstate = wxPyBeginAllowThreads();
46362 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46363 wxPyEndAllowThreads(__tstate);
46364 if (PyErr_Occurred()) SWIG_fail;
46365 }
46366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46367 return resultobj;
46368 fail:
46369 return NULL;
46370 }
46371
46372
46373 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46374 PyObject *resultobj = 0;
46375 wxSizer *arg1 = (wxSizer *) 0 ;
46376 PyObject *arg2 = (PyObject *) 0 ;
46377 bool result;
46378 void *argp1 = 0 ;
46379 int res1 = 0 ;
46380 PyObject * obj0 = 0 ;
46381 PyObject * obj1 = 0 ;
46382 char * kwnames[] = {
46383 (char *) "self",(char *) "item", NULL
46384 };
46385
46386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46388 if (!SWIG_IsOK(res1)) {
46389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46390 }
46391 arg1 = reinterpret_cast< wxSizer * >(argp1);
46392 arg2 = obj1;
46393 {
46394 PyThreadState* __tstate = wxPyBeginAllowThreads();
46395 result = (bool)wxSizer_Remove(arg1,arg2);
46396 wxPyEndAllowThreads(__tstate);
46397 if (PyErr_Occurred()) SWIG_fail;
46398 }
46399 {
46400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46401 }
46402 return resultobj;
46403 fail:
46404 return NULL;
46405 }
46406
46407
46408 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46409 PyObject *resultobj = 0;
46410 wxSizer *arg1 = (wxSizer *) 0 ;
46411 PyObject *arg2 = (PyObject *) 0 ;
46412 bool result;
46413 void *argp1 = 0 ;
46414 int res1 = 0 ;
46415 PyObject * obj0 = 0 ;
46416 PyObject * obj1 = 0 ;
46417 char * kwnames[] = {
46418 (char *) "self",(char *) "item", NULL
46419 };
46420
46421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46423 if (!SWIG_IsOK(res1)) {
46424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46425 }
46426 arg1 = reinterpret_cast< wxSizer * >(argp1);
46427 arg2 = obj1;
46428 {
46429 PyThreadState* __tstate = wxPyBeginAllowThreads();
46430 result = (bool)wxSizer_Detach(arg1,arg2);
46431 wxPyEndAllowThreads(__tstate);
46432 if (PyErr_Occurred()) SWIG_fail;
46433 }
46434 {
46435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46436 }
46437 return resultobj;
46438 fail:
46439 return NULL;
46440 }
46441
46442
46443 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46444 PyObject *resultobj = 0;
46445 wxSizer *arg1 = (wxSizer *) 0 ;
46446 PyObject *arg2 = (PyObject *) 0 ;
46447 wxSizerItem *result = 0 ;
46448 void *argp1 = 0 ;
46449 int res1 = 0 ;
46450 PyObject * obj0 = 0 ;
46451 PyObject * obj1 = 0 ;
46452 char * kwnames[] = {
46453 (char *) "self",(char *) "item", NULL
46454 };
46455
46456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46458 if (!SWIG_IsOK(res1)) {
46459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46460 }
46461 arg1 = reinterpret_cast< wxSizer * >(argp1);
46462 arg2 = obj1;
46463 {
46464 PyThreadState* __tstate = wxPyBeginAllowThreads();
46465 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46466 wxPyEndAllowThreads(__tstate);
46467 if (PyErr_Occurred()) SWIG_fail;
46468 }
46469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46470 return resultobj;
46471 fail:
46472 return NULL;
46473 }
46474
46475
46476 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46477 PyObject *resultobj = 0;
46478 wxSizer *arg1 = (wxSizer *) 0 ;
46479 PyObject *arg2 = (PyObject *) 0 ;
46480 wxSize *arg3 = 0 ;
46481 void *argp1 = 0 ;
46482 int res1 = 0 ;
46483 wxSize temp3 ;
46484 PyObject * obj0 = 0 ;
46485 PyObject * obj1 = 0 ;
46486 PyObject * obj2 = 0 ;
46487 char * kwnames[] = {
46488 (char *) "self",(char *) "item",(char *) "size", NULL
46489 };
46490
46491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46493 if (!SWIG_IsOK(res1)) {
46494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46495 }
46496 arg1 = reinterpret_cast< wxSizer * >(argp1);
46497 arg2 = obj1;
46498 {
46499 arg3 = &temp3;
46500 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46501 }
46502 {
46503 PyThreadState* __tstate = wxPyBeginAllowThreads();
46504 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46505 wxPyEndAllowThreads(__tstate);
46506 if (PyErr_Occurred()) SWIG_fail;
46507 }
46508 resultobj = SWIG_Py_Void();
46509 return resultobj;
46510 fail:
46511 return NULL;
46512 }
46513
46514
46515 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46516 PyObject *resultobj = 0;
46517 wxSizer *arg1 = (wxSizer *) 0 ;
46518 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46519 wxSizerItem *result = 0 ;
46520 void *argp1 = 0 ;
46521 int res1 = 0 ;
46522 int res2 = 0 ;
46523 PyObject * obj0 = 0 ;
46524 PyObject * obj1 = 0 ;
46525 char * kwnames[] = {
46526 (char *) "self",(char *) "item", NULL
46527 };
46528
46529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46531 if (!SWIG_IsOK(res1)) {
46532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46533 }
46534 arg1 = reinterpret_cast< wxSizer * >(argp1);
46535 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46536 if (!SWIG_IsOK(res2)) {
46537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46538 }
46539 {
46540 PyThreadState* __tstate = wxPyBeginAllowThreads();
46541 result = (wxSizerItem *)(arg1)->Add(arg2);
46542 wxPyEndAllowThreads(__tstate);
46543 if (PyErr_Occurred()) SWIG_fail;
46544 }
46545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46546 return resultobj;
46547 fail:
46548 return NULL;
46549 }
46550
46551
46552 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46553 PyObject *resultobj = 0;
46554 wxSizer *arg1 = (wxSizer *) 0 ;
46555 size_t arg2 ;
46556 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46557 wxSizerItem *result = 0 ;
46558 void *argp1 = 0 ;
46559 int res1 = 0 ;
46560 size_t val2 ;
46561 int ecode2 = 0 ;
46562 int res3 = 0 ;
46563 PyObject * obj0 = 0 ;
46564 PyObject * obj1 = 0 ;
46565 PyObject * obj2 = 0 ;
46566 char * kwnames[] = {
46567 (char *) "self",(char *) "index",(char *) "item", NULL
46568 };
46569
46570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46572 if (!SWIG_IsOK(res1)) {
46573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46574 }
46575 arg1 = reinterpret_cast< wxSizer * >(argp1);
46576 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46577 if (!SWIG_IsOK(ecode2)) {
46578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46579 }
46580 arg2 = static_cast< size_t >(val2);
46581 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46582 if (!SWIG_IsOK(res3)) {
46583 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46584 }
46585 {
46586 PyThreadState* __tstate = wxPyBeginAllowThreads();
46587 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46588 wxPyEndAllowThreads(__tstate);
46589 if (PyErr_Occurred()) SWIG_fail;
46590 }
46591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46592 return resultobj;
46593 fail:
46594 return NULL;
46595 }
46596
46597
46598 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46599 PyObject *resultobj = 0;
46600 wxSizer *arg1 = (wxSizer *) 0 ;
46601 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46602 wxSizerItem *result = 0 ;
46603 void *argp1 = 0 ;
46604 int res1 = 0 ;
46605 int res2 = 0 ;
46606 PyObject * obj0 = 0 ;
46607 PyObject * obj1 = 0 ;
46608 char * kwnames[] = {
46609 (char *) "self",(char *) "item", NULL
46610 };
46611
46612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46614 if (!SWIG_IsOK(res1)) {
46615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46616 }
46617 arg1 = reinterpret_cast< wxSizer * >(argp1);
46618 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46619 if (!SWIG_IsOK(res2)) {
46620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46621 }
46622 {
46623 PyThreadState* __tstate = wxPyBeginAllowThreads();
46624 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46625 wxPyEndAllowThreads(__tstate);
46626 if (PyErr_Occurred()) SWIG_fail;
46627 }
46628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46629 return resultobj;
46630 fail:
46631 return NULL;
46632 }
46633
46634
46635 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46636 PyObject *resultobj = 0;
46637 wxSizer *arg1 = (wxSizer *) 0 ;
46638 int arg2 ;
46639 int arg3 ;
46640 int arg4 ;
46641 int arg5 ;
46642 void *argp1 = 0 ;
46643 int res1 = 0 ;
46644 int val2 ;
46645 int ecode2 = 0 ;
46646 int val3 ;
46647 int ecode3 = 0 ;
46648 int val4 ;
46649 int ecode4 = 0 ;
46650 int val5 ;
46651 int ecode5 = 0 ;
46652 PyObject * obj0 = 0 ;
46653 PyObject * obj1 = 0 ;
46654 PyObject * obj2 = 0 ;
46655 PyObject * obj3 = 0 ;
46656 PyObject * obj4 = 0 ;
46657 char * kwnames[] = {
46658 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46659 };
46660
46661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46663 if (!SWIG_IsOK(res1)) {
46664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46665 }
46666 arg1 = reinterpret_cast< wxSizer * >(argp1);
46667 ecode2 = SWIG_AsVal_int(obj1, &val2);
46668 if (!SWIG_IsOK(ecode2)) {
46669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46670 }
46671 arg2 = static_cast< int >(val2);
46672 ecode3 = SWIG_AsVal_int(obj2, &val3);
46673 if (!SWIG_IsOK(ecode3)) {
46674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46675 }
46676 arg3 = static_cast< int >(val3);
46677 ecode4 = SWIG_AsVal_int(obj3, &val4);
46678 if (!SWIG_IsOK(ecode4)) {
46679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46680 }
46681 arg4 = static_cast< int >(val4);
46682 ecode5 = SWIG_AsVal_int(obj4, &val5);
46683 if (!SWIG_IsOK(ecode5)) {
46684 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46685 }
46686 arg5 = static_cast< int >(val5);
46687 {
46688 PyThreadState* __tstate = wxPyBeginAllowThreads();
46689 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46690 wxPyEndAllowThreads(__tstate);
46691 if (PyErr_Occurred()) SWIG_fail;
46692 }
46693 resultobj = SWIG_Py_Void();
46694 return resultobj;
46695 fail:
46696 return NULL;
46697 }
46698
46699
46700 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46701 PyObject *resultobj = 0;
46702 wxSizer *arg1 = (wxSizer *) 0 ;
46703 wxSize *arg2 = 0 ;
46704 void *argp1 = 0 ;
46705 int res1 = 0 ;
46706 wxSize temp2 ;
46707 PyObject * obj0 = 0 ;
46708 PyObject * obj1 = 0 ;
46709 char * kwnames[] = {
46710 (char *) "self",(char *) "size", NULL
46711 };
46712
46713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46715 if (!SWIG_IsOK(res1)) {
46716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46717 }
46718 arg1 = reinterpret_cast< wxSizer * >(argp1);
46719 {
46720 arg2 = &temp2;
46721 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46722 }
46723 {
46724 PyThreadState* __tstate = wxPyBeginAllowThreads();
46725 (arg1)->SetMinSize((wxSize const &)*arg2);
46726 wxPyEndAllowThreads(__tstate);
46727 if (PyErr_Occurred()) SWIG_fail;
46728 }
46729 resultobj = SWIG_Py_Void();
46730 return resultobj;
46731 fail:
46732 return NULL;
46733 }
46734
46735
46736 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46737 PyObject *resultobj = 0;
46738 wxSizer *arg1 = (wxSizer *) 0 ;
46739 wxSize result;
46740 void *argp1 = 0 ;
46741 int res1 = 0 ;
46742 PyObject *swig_obj[1] ;
46743
46744 if (!args) SWIG_fail;
46745 swig_obj[0] = args;
46746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46747 if (!SWIG_IsOK(res1)) {
46748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46749 }
46750 arg1 = reinterpret_cast< wxSizer * >(argp1);
46751 {
46752 PyThreadState* __tstate = wxPyBeginAllowThreads();
46753 result = (arg1)->GetSize();
46754 wxPyEndAllowThreads(__tstate);
46755 if (PyErr_Occurred()) SWIG_fail;
46756 }
46757 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46758 return resultobj;
46759 fail:
46760 return NULL;
46761 }
46762
46763
46764 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46765 PyObject *resultobj = 0;
46766 wxSizer *arg1 = (wxSizer *) 0 ;
46767 wxPoint result;
46768 void *argp1 = 0 ;
46769 int res1 = 0 ;
46770 PyObject *swig_obj[1] ;
46771
46772 if (!args) SWIG_fail;
46773 swig_obj[0] = args;
46774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46775 if (!SWIG_IsOK(res1)) {
46776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46777 }
46778 arg1 = reinterpret_cast< wxSizer * >(argp1);
46779 {
46780 PyThreadState* __tstate = wxPyBeginAllowThreads();
46781 result = (arg1)->GetPosition();
46782 wxPyEndAllowThreads(__tstate);
46783 if (PyErr_Occurred()) SWIG_fail;
46784 }
46785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46786 return resultobj;
46787 fail:
46788 return NULL;
46789 }
46790
46791
46792 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46793 PyObject *resultobj = 0;
46794 wxSizer *arg1 = (wxSizer *) 0 ;
46795 wxSize result;
46796 void *argp1 = 0 ;
46797 int res1 = 0 ;
46798 PyObject *swig_obj[1] ;
46799
46800 if (!args) SWIG_fail;
46801 swig_obj[0] = args;
46802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46803 if (!SWIG_IsOK(res1)) {
46804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46805 }
46806 arg1 = reinterpret_cast< wxSizer * >(argp1);
46807 {
46808 PyThreadState* __tstate = wxPyBeginAllowThreads();
46809 result = (arg1)->GetMinSize();
46810 wxPyEndAllowThreads(__tstate);
46811 if (PyErr_Occurred()) SWIG_fail;
46812 }
46813 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46814 return resultobj;
46815 fail:
46816 return NULL;
46817 }
46818
46819
46820 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46821 PyObject *resultobj = 0;
46822 wxSizer *arg1 = (wxSizer *) 0 ;
46823 void *argp1 = 0 ;
46824 int res1 = 0 ;
46825 PyObject *swig_obj[1] ;
46826
46827 if (!args) SWIG_fail;
46828 swig_obj[0] = args;
46829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46830 if (!SWIG_IsOK(res1)) {
46831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46832 }
46833 arg1 = reinterpret_cast< wxSizer * >(argp1);
46834 {
46835 PyThreadState* __tstate = wxPyBeginAllowThreads();
46836 (arg1)->RecalcSizes();
46837 wxPyEndAllowThreads(__tstate);
46838 if (PyErr_Occurred()) SWIG_fail;
46839 }
46840 resultobj = SWIG_Py_Void();
46841 return resultobj;
46842 fail:
46843 return NULL;
46844 }
46845
46846
46847 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46848 PyObject *resultobj = 0;
46849 wxSizer *arg1 = (wxSizer *) 0 ;
46850 wxSize result;
46851 void *argp1 = 0 ;
46852 int res1 = 0 ;
46853 PyObject *swig_obj[1] ;
46854
46855 if (!args) SWIG_fail;
46856 swig_obj[0] = args;
46857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46858 if (!SWIG_IsOK(res1)) {
46859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46860 }
46861 arg1 = reinterpret_cast< wxSizer * >(argp1);
46862 {
46863 PyThreadState* __tstate = wxPyBeginAllowThreads();
46864 result = (arg1)->CalcMin();
46865 wxPyEndAllowThreads(__tstate);
46866 if (PyErr_Occurred()) SWIG_fail;
46867 }
46868 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46869 return resultobj;
46870 fail:
46871 return NULL;
46872 }
46873
46874
46875 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46876 PyObject *resultobj = 0;
46877 wxSizer *arg1 = (wxSizer *) 0 ;
46878 void *argp1 = 0 ;
46879 int res1 = 0 ;
46880 PyObject *swig_obj[1] ;
46881
46882 if (!args) SWIG_fail;
46883 swig_obj[0] = args;
46884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46885 if (!SWIG_IsOK(res1)) {
46886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46887 }
46888 arg1 = reinterpret_cast< wxSizer * >(argp1);
46889 {
46890 PyThreadState* __tstate = wxPyBeginAllowThreads();
46891 (arg1)->Layout();
46892 wxPyEndAllowThreads(__tstate);
46893 if (PyErr_Occurred()) SWIG_fail;
46894 }
46895 resultobj = SWIG_Py_Void();
46896 return resultobj;
46897 fail:
46898 return NULL;
46899 }
46900
46901
46902 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46903 PyObject *resultobj = 0;
46904 wxSizer *arg1 = (wxSizer *) 0 ;
46905 wxWindow *arg2 = (wxWindow *) 0 ;
46906 wxSize result;
46907 void *argp1 = 0 ;
46908 int res1 = 0 ;
46909 void *argp2 = 0 ;
46910 int res2 = 0 ;
46911 PyObject * obj0 = 0 ;
46912 PyObject * obj1 = 0 ;
46913 char * kwnames[] = {
46914 (char *) "self",(char *) "window", NULL
46915 };
46916
46917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46919 if (!SWIG_IsOK(res1)) {
46920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46921 }
46922 arg1 = reinterpret_cast< wxSizer * >(argp1);
46923 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46924 if (!SWIG_IsOK(res2)) {
46925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46926 }
46927 arg2 = reinterpret_cast< wxWindow * >(argp2);
46928 {
46929 PyThreadState* __tstate = wxPyBeginAllowThreads();
46930 result = (arg1)->Fit(arg2);
46931 wxPyEndAllowThreads(__tstate);
46932 if (PyErr_Occurred()) SWIG_fail;
46933 }
46934 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46935 return resultobj;
46936 fail:
46937 return NULL;
46938 }
46939
46940
46941 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46942 PyObject *resultobj = 0;
46943 wxSizer *arg1 = (wxSizer *) 0 ;
46944 wxWindow *arg2 = (wxWindow *) 0 ;
46945 void *argp1 = 0 ;
46946 int res1 = 0 ;
46947 void *argp2 = 0 ;
46948 int res2 = 0 ;
46949 PyObject * obj0 = 0 ;
46950 PyObject * obj1 = 0 ;
46951 char * kwnames[] = {
46952 (char *) "self",(char *) "window", NULL
46953 };
46954
46955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46957 if (!SWIG_IsOK(res1)) {
46958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46959 }
46960 arg1 = reinterpret_cast< wxSizer * >(argp1);
46961 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46962 if (!SWIG_IsOK(res2)) {
46963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46964 }
46965 arg2 = reinterpret_cast< wxWindow * >(argp2);
46966 {
46967 PyThreadState* __tstate = wxPyBeginAllowThreads();
46968 (arg1)->FitInside(arg2);
46969 wxPyEndAllowThreads(__tstate);
46970 if (PyErr_Occurred()) SWIG_fail;
46971 }
46972 resultobj = SWIG_Py_Void();
46973 return resultobj;
46974 fail:
46975 return NULL;
46976 }
46977
46978
46979 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46980 PyObject *resultobj = 0;
46981 wxSizer *arg1 = (wxSizer *) 0 ;
46982 wxWindow *arg2 = (wxWindow *) 0 ;
46983 void *argp1 = 0 ;
46984 int res1 = 0 ;
46985 void *argp2 = 0 ;
46986 int res2 = 0 ;
46987 PyObject * obj0 = 0 ;
46988 PyObject * obj1 = 0 ;
46989 char * kwnames[] = {
46990 (char *) "self",(char *) "window", NULL
46991 };
46992
46993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46995 if (!SWIG_IsOK(res1)) {
46996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46997 }
46998 arg1 = reinterpret_cast< wxSizer * >(argp1);
46999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47000 if (!SWIG_IsOK(res2)) {
47001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47002 }
47003 arg2 = reinterpret_cast< wxWindow * >(argp2);
47004 {
47005 PyThreadState* __tstate = wxPyBeginAllowThreads();
47006 (arg1)->SetSizeHints(arg2);
47007 wxPyEndAllowThreads(__tstate);
47008 if (PyErr_Occurred()) SWIG_fail;
47009 }
47010 resultobj = SWIG_Py_Void();
47011 return resultobj;
47012 fail:
47013 return NULL;
47014 }
47015
47016
47017 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47018 PyObject *resultobj = 0;
47019 wxSizer *arg1 = (wxSizer *) 0 ;
47020 wxWindow *arg2 = (wxWindow *) 0 ;
47021 void *argp1 = 0 ;
47022 int res1 = 0 ;
47023 void *argp2 = 0 ;
47024 int res2 = 0 ;
47025 PyObject * obj0 = 0 ;
47026 PyObject * obj1 = 0 ;
47027 char * kwnames[] = {
47028 (char *) "self",(char *) "window", NULL
47029 };
47030
47031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47033 if (!SWIG_IsOK(res1)) {
47034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47035 }
47036 arg1 = reinterpret_cast< wxSizer * >(argp1);
47037 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47038 if (!SWIG_IsOK(res2)) {
47039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47040 }
47041 arg2 = reinterpret_cast< wxWindow * >(argp2);
47042 {
47043 PyThreadState* __tstate = wxPyBeginAllowThreads();
47044 (arg1)->SetVirtualSizeHints(arg2);
47045 wxPyEndAllowThreads(__tstate);
47046 if (PyErr_Occurred()) SWIG_fail;
47047 }
47048 resultobj = SWIG_Py_Void();
47049 return resultobj;
47050 fail:
47051 return NULL;
47052 }
47053
47054
47055 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47056 PyObject *resultobj = 0;
47057 wxSizer *arg1 = (wxSizer *) 0 ;
47058 bool arg2 = (bool) false ;
47059 void *argp1 = 0 ;
47060 int res1 = 0 ;
47061 bool val2 ;
47062 int ecode2 = 0 ;
47063 PyObject * obj0 = 0 ;
47064 PyObject * obj1 = 0 ;
47065 char * kwnames[] = {
47066 (char *) "self",(char *) "deleteWindows", NULL
47067 };
47068
47069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47071 if (!SWIG_IsOK(res1)) {
47072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47073 }
47074 arg1 = reinterpret_cast< wxSizer * >(argp1);
47075 if (obj1) {
47076 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47077 if (!SWIG_IsOK(ecode2)) {
47078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47079 }
47080 arg2 = static_cast< bool >(val2);
47081 }
47082 {
47083 PyThreadState* __tstate = wxPyBeginAllowThreads();
47084 (arg1)->Clear(arg2);
47085 wxPyEndAllowThreads(__tstate);
47086 if (PyErr_Occurred()) SWIG_fail;
47087 }
47088 resultobj = SWIG_Py_Void();
47089 return resultobj;
47090 fail:
47091 return NULL;
47092 }
47093
47094
47095 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47096 PyObject *resultobj = 0;
47097 wxSizer *arg1 = (wxSizer *) 0 ;
47098 void *argp1 = 0 ;
47099 int res1 = 0 ;
47100 PyObject *swig_obj[1] ;
47101
47102 if (!args) SWIG_fail;
47103 swig_obj[0] = args;
47104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47105 if (!SWIG_IsOK(res1)) {
47106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47107 }
47108 arg1 = reinterpret_cast< wxSizer * >(argp1);
47109 {
47110 PyThreadState* __tstate = wxPyBeginAllowThreads();
47111 (arg1)->DeleteWindows();
47112 wxPyEndAllowThreads(__tstate);
47113 if (PyErr_Occurred()) SWIG_fail;
47114 }
47115 resultobj = SWIG_Py_Void();
47116 return resultobj;
47117 fail:
47118 return NULL;
47119 }
47120
47121
47122 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47123 PyObject *resultobj = 0;
47124 wxSizer *arg1 = (wxSizer *) 0 ;
47125 PyObject *result = 0 ;
47126 void *argp1 = 0 ;
47127 int res1 = 0 ;
47128 PyObject *swig_obj[1] ;
47129
47130 if (!args) SWIG_fail;
47131 swig_obj[0] = args;
47132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47133 if (!SWIG_IsOK(res1)) {
47134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47135 }
47136 arg1 = reinterpret_cast< wxSizer * >(argp1);
47137 {
47138 PyThreadState* __tstate = wxPyBeginAllowThreads();
47139 result = (PyObject *)wxSizer_GetChildren(arg1);
47140 wxPyEndAllowThreads(__tstate);
47141 if (PyErr_Occurred()) SWIG_fail;
47142 }
47143 resultobj = result;
47144 return resultobj;
47145 fail:
47146 return NULL;
47147 }
47148
47149
47150 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47151 PyObject *resultobj = 0;
47152 wxSizer *arg1 = (wxSizer *) 0 ;
47153 PyObject *arg2 = (PyObject *) 0 ;
47154 bool arg3 = (bool) true ;
47155 bool arg4 = (bool) false ;
47156 bool result;
47157 void *argp1 = 0 ;
47158 int res1 = 0 ;
47159 bool val3 ;
47160 int ecode3 = 0 ;
47161 bool val4 ;
47162 int ecode4 = 0 ;
47163 PyObject * obj0 = 0 ;
47164 PyObject * obj1 = 0 ;
47165 PyObject * obj2 = 0 ;
47166 PyObject * obj3 = 0 ;
47167 char * kwnames[] = {
47168 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47169 };
47170
47171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47173 if (!SWIG_IsOK(res1)) {
47174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47175 }
47176 arg1 = reinterpret_cast< wxSizer * >(argp1);
47177 arg2 = obj1;
47178 if (obj2) {
47179 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47180 if (!SWIG_IsOK(ecode3)) {
47181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47182 }
47183 arg3 = static_cast< bool >(val3);
47184 }
47185 if (obj3) {
47186 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47187 if (!SWIG_IsOK(ecode4)) {
47188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47189 }
47190 arg4 = static_cast< bool >(val4);
47191 }
47192 {
47193 PyThreadState* __tstate = wxPyBeginAllowThreads();
47194 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47195 wxPyEndAllowThreads(__tstate);
47196 if (PyErr_Occurred()) SWIG_fail;
47197 }
47198 {
47199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47200 }
47201 return resultobj;
47202 fail:
47203 return NULL;
47204 }
47205
47206
47207 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47208 PyObject *resultobj = 0;
47209 wxSizer *arg1 = (wxSizer *) 0 ;
47210 PyObject *arg2 = (PyObject *) 0 ;
47211 bool result;
47212 void *argp1 = 0 ;
47213 int res1 = 0 ;
47214 PyObject * obj0 = 0 ;
47215 PyObject * obj1 = 0 ;
47216 char * kwnames[] = {
47217 (char *) "self",(char *) "item", NULL
47218 };
47219
47220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47222 if (!SWIG_IsOK(res1)) {
47223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47224 }
47225 arg1 = reinterpret_cast< wxSizer * >(argp1);
47226 arg2 = obj1;
47227 {
47228 PyThreadState* __tstate = wxPyBeginAllowThreads();
47229 result = (bool)wxSizer_IsShown(arg1,arg2);
47230 wxPyEndAllowThreads(__tstate);
47231 if (PyErr_Occurred()) SWIG_fail;
47232 }
47233 {
47234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47235 }
47236 return resultobj;
47237 fail:
47238 return NULL;
47239 }
47240
47241
47242 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47243 PyObject *resultobj = 0;
47244 wxSizer *arg1 = (wxSizer *) 0 ;
47245 bool arg2 ;
47246 void *argp1 = 0 ;
47247 int res1 = 0 ;
47248 bool val2 ;
47249 int ecode2 = 0 ;
47250 PyObject * obj0 = 0 ;
47251 PyObject * obj1 = 0 ;
47252 char * kwnames[] = {
47253 (char *) "self",(char *) "show", NULL
47254 };
47255
47256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47258 if (!SWIG_IsOK(res1)) {
47259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47260 }
47261 arg1 = reinterpret_cast< wxSizer * >(argp1);
47262 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47263 if (!SWIG_IsOK(ecode2)) {
47264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47265 }
47266 arg2 = static_cast< bool >(val2);
47267 {
47268 PyThreadState* __tstate = wxPyBeginAllowThreads();
47269 (arg1)->ShowItems(arg2);
47270 wxPyEndAllowThreads(__tstate);
47271 if (PyErr_Occurred()) SWIG_fail;
47272 }
47273 resultobj = SWIG_Py_Void();
47274 return resultobj;
47275 fail:
47276 return NULL;
47277 }
47278
47279
47280 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47281 PyObject *obj;
47282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47283 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47284 return SWIG_Py_Void();
47285 }
47286
47287 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47288 PyObject *resultobj = 0;
47289 wxPySizer *result = 0 ;
47290
47291 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47292 {
47293 PyThreadState* __tstate = wxPyBeginAllowThreads();
47294 result = (wxPySizer *)new wxPySizer();
47295 wxPyEndAllowThreads(__tstate);
47296 if (PyErr_Occurred()) SWIG_fail;
47297 }
47298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47299 return resultobj;
47300 fail:
47301 return NULL;
47302 }
47303
47304
47305 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47306 PyObject *resultobj = 0;
47307 wxPySizer *arg1 = (wxPySizer *) 0 ;
47308 PyObject *arg2 = (PyObject *) 0 ;
47309 PyObject *arg3 = (PyObject *) 0 ;
47310 void *argp1 = 0 ;
47311 int res1 = 0 ;
47312 PyObject * obj0 = 0 ;
47313 PyObject * obj1 = 0 ;
47314 PyObject * obj2 = 0 ;
47315 char * kwnames[] = {
47316 (char *) "self",(char *) "self",(char *) "_class", NULL
47317 };
47318
47319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47321 if (!SWIG_IsOK(res1)) {
47322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47323 }
47324 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47325 arg2 = obj1;
47326 arg3 = obj2;
47327 {
47328 PyThreadState* __tstate = wxPyBeginAllowThreads();
47329 (arg1)->_setCallbackInfo(arg2,arg3);
47330 wxPyEndAllowThreads(__tstate);
47331 if (PyErr_Occurred()) SWIG_fail;
47332 }
47333 resultobj = SWIG_Py_Void();
47334 return resultobj;
47335 fail:
47336 return NULL;
47337 }
47338
47339
47340 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47341 PyObject *obj;
47342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47343 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47344 return SWIG_Py_Void();
47345 }
47346
47347 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47348 return SWIG_Python_InitShadowInstance(args);
47349 }
47350
47351 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47352 PyObject *resultobj = 0;
47353 int arg1 = (int) wxHORIZONTAL ;
47354 wxBoxSizer *result = 0 ;
47355 int val1 ;
47356 int ecode1 = 0 ;
47357 PyObject * obj0 = 0 ;
47358 char * kwnames[] = {
47359 (char *) "orient", NULL
47360 };
47361
47362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47363 if (obj0) {
47364 ecode1 = SWIG_AsVal_int(obj0, &val1);
47365 if (!SWIG_IsOK(ecode1)) {
47366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47367 }
47368 arg1 = static_cast< int >(val1);
47369 }
47370 {
47371 PyThreadState* __tstate = wxPyBeginAllowThreads();
47372 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47373 wxPyEndAllowThreads(__tstate);
47374 if (PyErr_Occurred()) SWIG_fail;
47375 }
47376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47377 return resultobj;
47378 fail:
47379 return NULL;
47380 }
47381
47382
47383 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47384 PyObject *resultobj = 0;
47385 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47386 int result;
47387 void *argp1 = 0 ;
47388 int res1 = 0 ;
47389 PyObject *swig_obj[1] ;
47390
47391 if (!args) SWIG_fail;
47392 swig_obj[0] = args;
47393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47394 if (!SWIG_IsOK(res1)) {
47395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47396 }
47397 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47398 {
47399 PyThreadState* __tstate = wxPyBeginAllowThreads();
47400 result = (int)(arg1)->GetOrientation();
47401 wxPyEndAllowThreads(__tstate);
47402 if (PyErr_Occurred()) SWIG_fail;
47403 }
47404 resultobj = SWIG_From_int(static_cast< int >(result));
47405 return resultobj;
47406 fail:
47407 return NULL;
47408 }
47409
47410
47411 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47412 PyObject *resultobj = 0;
47413 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47414 int arg2 ;
47415 void *argp1 = 0 ;
47416 int res1 = 0 ;
47417 int val2 ;
47418 int ecode2 = 0 ;
47419 PyObject * obj0 = 0 ;
47420 PyObject * obj1 = 0 ;
47421 char * kwnames[] = {
47422 (char *) "self",(char *) "orient", NULL
47423 };
47424
47425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47427 if (!SWIG_IsOK(res1)) {
47428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47429 }
47430 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47431 ecode2 = SWIG_AsVal_int(obj1, &val2);
47432 if (!SWIG_IsOK(ecode2)) {
47433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47434 }
47435 arg2 = static_cast< int >(val2);
47436 {
47437 PyThreadState* __tstate = wxPyBeginAllowThreads();
47438 (arg1)->SetOrientation(arg2);
47439 wxPyEndAllowThreads(__tstate);
47440 if (PyErr_Occurred()) SWIG_fail;
47441 }
47442 resultobj = SWIG_Py_Void();
47443 return resultobj;
47444 fail:
47445 return NULL;
47446 }
47447
47448
47449 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47450 PyObject *obj;
47451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47452 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47453 return SWIG_Py_Void();
47454 }
47455
47456 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47457 return SWIG_Python_InitShadowInstance(args);
47458 }
47459
47460 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47461 PyObject *resultobj = 0;
47462 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47463 int arg2 = (int) wxHORIZONTAL ;
47464 wxStaticBoxSizer *result = 0 ;
47465 void *argp1 = 0 ;
47466 int res1 = 0 ;
47467 int val2 ;
47468 int ecode2 = 0 ;
47469 PyObject * obj0 = 0 ;
47470 PyObject * obj1 = 0 ;
47471 char * kwnames[] = {
47472 (char *) "box",(char *) "orient", NULL
47473 };
47474
47475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47477 if (!SWIG_IsOK(res1)) {
47478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47479 }
47480 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47481 if (obj1) {
47482 ecode2 = SWIG_AsVal_int(obj1, &val2);
47483 if (!SWIG_IsOK(ecode2)) {
47484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47485 }
47486 arg2 = static_cast< int >(val2);
47487 }
47488 {
47489 PyThreadState* __tstate = wxPyBeginAllowThreads();
47490 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47491 wxPyEndAllowThreads(__tstate);
47492 if (PyErr_Occurred()) SWIG_fail;
47493 }
47494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47495 return resultobj;
47496 fail:
47497 return NULL;
47498 }
47499
47500
47501 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47502 PyObject *resultobj = 0;
47503 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47504 wxStaticBox *result = 0 ;
47505 void *argp1 = 0 ;
47506 int res1 = 0 ;
47507 PyObject *swig_obj[1] ;
47508
47509 if (!args) SWIG_fail;
47510 swig_obj[0] = args;
47511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47512 if (!SWIG_IsOK(res1)) {
47513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47514 }
47515 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47516 {
47517 PyThreadState* __tstate = wxPyBeginAllowThreads();
47518 result = (wxStaticBox *)(arg1)->GetStaticBox();
47519 wxPyEndAllowThreads(__tstate);
47520 if (PyErr_Occurred()) SWIG_fail;
47521 }
47522 {
47523 resultobj = wxPyMake_wxObject(result, (bool)0);
47524 }
47525 return resultobj;
47526 fail:
47527 return NULL;
47528 }
47529
47530
47531 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47532 PyObject *obj;
47533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47534 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47535 return SWIG_Py_Void();
47536 }
47537
47538 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47539 return SWIG_Python_InitShadowInstance(args);
47540 }
47541
47542 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47543 PyObject *resultobj = 0;
47544 int arg1 = (int) 1 ;
47545 int arg2 = (int) 0 ;
47546 int arg3 = (int) 0 ;
47547 int arg4 = (int) 0 ;
47548 wxGridSizer *result = 0 ;
47549 int val1 ;
47550 int ecode1 = 0 ;
47551 int val2 ;
47552 int ecode2 = 0 ;
47553 int val3 ;
47554 int ecode3 = 0 ;
47555 int val4 ;
47556 int ecode4 = 0 ;
47557 PyObject * obj0 = 0 ;
47558 PyObject * obj1 = 0 ;
47559 PyObject * obj2 = 0 ;
47560 PyObject * obj3 = 0 ;
47561 char * kwnames[] = {
47562 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47563 };
47564
47565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47566 if (obj0) {
47567 ecode1 = SWIG_AsVal_int(obj0, &val1);
47568 if (!SWIG_IsOK(ecode1)) {
47569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47570 }
47571 arg1 = static_cast< int >(val1);
47572 }
47573 if (obj1) {
47574 ecode2 = SWIG_AsVal_int(obj1, &val2);
47575 if (!SWIG_IsOK(ecode2)) {
47576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47577 }
47578 arg2 = static_cast< int >(val2);
47579 }
47580 if (obj2) {
47581 ecode3 = SWIG_AsVal_int(obj2, &val3);
47582 if (!SWIG_IsOK(ecode3)) {
47583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47584 }
47585 arg3 = static_cast< int >(val3);
47586 }
47587 if (obj3) {
47588 ecode4 = SWIG_AsVal_int(obj3, &val4);
47589 if (!SWIG_IsOK(ecode4)) {
47590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47591 }
47592 arg4 = static_cast< int >(val4);
47593 }
47594 {
47595 PyThreadState* __tstate = wxPyBeginAllowThreads();
47596 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47597 wxPyEndAllowThreads(__tstate);
47598 if (PyErr_Occurred()) SWIG_fail;
47599 }
47600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47601 return resultobj;
47602 fail:
47603 return NULL;
47604 }
47605
47606
47607 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47608 PyObject *resultobj = 0;
47609 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47610 int arg2 ;
47611 void *argp1 = 0 ;
47612 int res1 = 0 ;
47613 int val2 ;
47614 int ecode2 = 0 ;
47615 PyObject * obj0 = 0 ;
47616 PyObject * obj1 = 0 ;
47617 char * kwnames[] = {
47618 (char *) "self",(char *) "cols", NULL
47619 };
47620
47621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47623 if (!SWIG_IsOK(res1)) {
47624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47625 }
47626 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47627 ecode2 = SWIG_AsVal_int(obj1, &val2);
47628 if (!SWIG_IsOK(ecode2)) {
47629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47630 }
47631 arg2 = static_cast< int >(val2);
47632 {
47633 PyThreadState* __tstate = wxPyBeginAllowThreads();
47634 (arg1)->SetCols(arg2);
47635 wxPyEndAllowThreads(__tstate);
47636 if (PyErr_Occurred()) SWIG_fail;
47637 }
47638 resultobj = SWIG_Py_Void();
47639 return resultobj;
47640 fail:
47641 return NULL;
47642 }
47643
47644
47645 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47646 PyObject *resultobj = 0;
47647 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47648 int arg2 ;
47649 void *argp1 = 0 ;
47650 int res1 = 0 ;
47651 int val2 ;
47652 int ecode2 = 0 ;
47653 PyObject * obj0 = 0 ;
47654 PyObject * obj1 = 0 ;
47655 char * kwnames[] = {
47656 (char *) "self",(char *) "rows", NULL
47657 };
47658
47659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47661 if (!SWIG_IsOK(res1)) {
47662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47663 }
47664 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47665 ecode2 = SWIG_AsVal_int(obj1, &val2);
47666 if (!SWIG_IsOK(ecode2)) {
47667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47668 }
47669 arg2 = static_cast< int >(val2);
47670 {
47671 PyThreadState* __tstate = wxPyBeginAllowThreads();
47672 (arg1)->SetRows(arg2);
47673 wxPyEndAllowThreads(__tstate);
47674 if (PyErr_Occurred()) SWIG_fail;
47675 }
47676 resultobj = SWIG_Py_Void();
47677 return resultobj;
47678 fail:
47679 return NULL;
47680 }
47681
47682
47683 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47684 PyObject *resultobj = 0;
47685 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47686 int arg2 ;
47687 void *argp1 = 0 ;
47688 int res1 = 0 ;
47689 int val2 ;
47690 int ecode2 = 0 ;
47691 PyObject * obj0 = 0 ;
47692 PyObject * obj1 = 0 ;
47693 char * kwnames[] = {
47694 (char *) "self",(char *) "gap", NULL
47695 };
47696
47697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47699 if (!SWIG_IsOK(res1)) {
47700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47701 }
47702 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47703 ecode2 = SWIG_AsVal_int(obj1, &val2);
47704 if (!SWIG_IsOK(ecode2)) {
47705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47706 }
47707 arg2 = static_cast< int >(val2);
47708 {
47709 PyThreadState* __tstate = wxPyBeginAllowThreads();
47710 (arg1)->SetVGap(arg2);
47711 wxPyEndAllowThreads(__tstate);
47712 if (PyErr_Occurred()) SWIG_fail;
47713 }
47714 resultobj = SWIG_Py_Void();
47715 return resultobj;
47716 fail:
47717 return NULL;
47718 }
47719
47720
47721 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47722 PyObject *resultobj = 0;
47723 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47724 int arg2 ;
47725 void *argp1 = 0 ;
47726 int res1 = 0 ;
47727 int val2 ;
47728 int ecode2 = 0 ;
47729 PyObject * obj0 = 0 ;
47730 PyObject * obj1 = 0 ;
47731 char * kwnames[] = {
47732 (char *) "self",(char *) "gap", NULL
47733 };
47734
47735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47737 if (!SWIG_IsOK(res1)) {
47738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47739 }
47740 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47741 ecode2 = SWIG_AsVal_int(obj1, &val2);
47742 if (!SWIG_IsOK(ecode2)) {
47743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47744 }
47745 arg2 = static_cast< int >(val2);
47746 {
47747 PyThreadState* __tstate = wxPyBeginAllowThreads();
47748 (arg1)->SetHGap(arg2);
47749 wxPyEndAllowThreads(__tstate);
47750 if (PyErr_Occurred()) SWIG_fail;
47751 }
47752 resultobj = SWIG_Py_Void();
47753 return resultobj;
47754 fail:
47755 return NULL;
47756 }
47757
47758
47759 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47760 PyObject *resultobj = 0;
47761 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47762 int result;
47763 void *argp1 = 0 ;
47764 int res1 = 0 ;
47765 PyObject *swig_obj[1] ;
47766
47767 if (!args) SWIG_fail;
47768 swig_obj[0] = args;
47769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47770 if (!SWIG_IsOK(res1)) {
47771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47772 }
47773 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47774 {
47775 PyThreadState* __tstate = wxPyBeginAllowThreads();
47776 result = (int)(arg1)->GetCols();
47777 wxPyEndAllowThreads(__tstate);
47778 if (PyErr_Occurred()) SWIG_fail;
47779 }
47780 resultobj = SWIG_From_int(static_cast< int >(result));
47781 return resultobj;
47782 fail:
47783 return NULL;
47784 }
47785
47786
47787 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47788 PyObject *resultobj = 0;
47789 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47790 int result;
47791 void *argp1 = 0 ;
47792 int res1 = 0 ;
47793 PyObject *swig_obj[1] ;
47794
47795 if (!args) SWIG_fail;
47796 swig_obj[0] = args;
47797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47798 if (!SWIG_IsOK(res1)) {
47799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47800 }
47801 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47802 {
47803 PyThreadState* __tstate = wxPyBeginAllowThreads();
47804 result = (int)(arg1)->GetRows();
47805 wxPyEndAllowThreads(__tstate);
47806 if (PyErr_Occurred()) SWIG_fail;
47807 }
47808 resultobj = SWIG_From_int(static_cast< int >(result));
47809 return resultobj;
47810 fail:
47811 return NULL;
47812 }
47813
47814
47815 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47816 PyObject *resultobj = 0;
47817 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47818 int result;
47819 void *argp1 = 0 ;
47820 int res1 = 0 ;
47821 PyObject *swig_obj[1] ;
47822
47823 if (!args) SWIG_fail;
47824 swig_obj[0] = args;
47825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47826 if (!SWIG_IsOK(res1)) {
47827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47828 }
47829 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47830 {
47831 PyThreadState* __tstate = wxPyBeginAllowThreads();
47832 result = (int)(arg1)->GetVGap();
47833 wxPyEndAllowThreads(__tstate);
47834 if (PyErr_Occurred()) SWIG_fail;
47835 }
47836 resultobj = SWIG_From_int(static_cast< int >(result));
47837 return resultobj;
47838 fail:
47839 return NULL;
47840 }
47841
47842
47843 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47844 PyObject *resultobj = 0;
47845 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47846 int result;
47847 void *argp1 = 0 ;
47848 int res1 = 0 ;
47849 PyObject *swig_obj[1] ;
47850
47851 if (!args) SWIG_fail;
47852 swig_obj[0] = args;
47853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47854 if (!SWIG_IsOK(res1)) {
47855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47856 }
47857 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47858 {
47859 PyThreadState* __tstate = wxPyBeginAllowThreads();
47860 result = (int)(arg1)->GetHGap();
47861 wxPyEndAllowThreads(__tstate);
47862 if (PyErr_Occurred()) SWIG_fail;
47863 }
47864 resultobj = SWIG_From_int(static_cast< int >(result));
47865 return resultobj;
47866 fail:
47867 return NULL;
47868 }
47869
47870
47871 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47872 PyObject *obj;
47873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47874 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47875 return SWIG_Py_Void();
47876 }
47877
47878 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47879 return SWIG_Python_InitShadowInstance(args);
47880 }
47881
47882 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47883 PyObject *resultobj = 0;
47884 int arg1 = (int) 1 ;
47885 int arg2 = (int) 0 ;
47886 int arg3 = (int) 0 ;
47887 int arg4 = (int) 0 ;
47888 wxFlexGridSizer *result = 0 ;
47889 int val1 ;
47890 int ecode1 = 0 ;
47891 int val2 ;
47892 int ecode2 = 0 ;
47893 int val3 ;
47894 int ecode3 = 0 ;
47895 int val4 ;
47896 int ecode4 = 0 ;
47897 PyObject * obj0 = 0 ;
47898 PyObject * obj1 = 0 ;
47899 PyObject * obj2 = 0 ;
47900 PyObject * obj3 = 0 ;
47901 char * kwnames[] = {
47902 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47903 };
47904
47905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47906 if (obj0) {
47907 ecode1 = SWIG_AsVal_int(obj0, &val1);
47908 if (!SWIG_IsOK(ecode1)) {
47909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47910 }
47911 arg1 = static_cast< int >(val1);
47912 }
47913 if (obj1) {
47914 ecode2 = SWIG_AsVal_int(obj1, &val2);
47915 if (!SWIG_IsOK(ecode2)) {
47916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47917 }
47918 arg2 = static_cast< int >(val2);
47919 }
47920 if (obj2) {
47921 ecode3 = SWIG_AsVal_int(obj2, &val3);
47922 if (!SWIG_IsOK(ecode3)) {
47923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47924 }
47925 arg3 = static_cast< int >(val3);
47926 }
47927 if (obj3) {
47928 ecode4 = SWIG_AsVal_int(obj3, &val4);
47929 if (!SWIG_IsOK(ecode4)) {
47930 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47931 }
47932 arg4 = static_cast< int >(val4);
47933 }
47934 {
47935 PyThreadState* __tstate = wxPyBeginAllowThreads();
47936 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47937 wxPyEndAllowThreads(__tstate);
47938 if (PyErr_Occurred()) SWIG_fail;
47939 }
47940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47941 return resultobj;
47942 fail:
47943 return NULL;
47944 }
47945
47946
47947 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47948 PyObject *resultobj = 0;
47949 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47950 size_t arg2 ;
47951 int arg3 = (int) 0 ;
47952 void *argp1 = 0 ;
47953 int res1 = 0 ;
47954 size_t val2 ;
47955 int ecode2 = 0 ;
47956 int val3 ;
47957 int ecode3 = 0 ;
47958 PyObject * obj0 = 0 ;
47959 PyObject * obj1 = 0 ;
47960 PyObject * obj2 = 0 ;
47961 char * kwnames[] = {
47962 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47963 };
47964
47965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47967 if (!SWIG_IsOK(res1)) {
47968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47969 }
47970 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47971 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47972 if (!SWIG_IsOK(ecode2)) {
47973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47974 }
47975 arg2 = static_cast< size_t >(val2);
47976 if (obj2) {
47977 ecode3 = SWIG_AsVal_int(obj2, &val3);
47978 if (!SWIG_IsOK(ecode3)) {
47979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47980 }
47981 arg3 = static_cast< int >(val3);
47982 }
47983 {
47984 PyThreadState* __tstate = wxPyBeginAllowThreads();
47985 (arg1)->AddGrowableRow(arg2,arg3);
47986 wxPyEndAllowThreads(__tstate);
47987 if (PyErr_Occurred()) SWIG_fail;
47988 }
47989 resultobj = SWIG_Py_Void();
47990 return resultobj;
47991 fail:
47992 return NULL;
47993 }
47994
47995
47996 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47997 PyObject *resultobj = 0;
47998 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47999 size_t arg2 ;
48000 void *argp1 = 0 ;
48001 int res1 = 0 ;
48002 size_t val2 ;
48003 int ecode2 = 0 ;
48004 PyObject * obj0 = 0 ;
48005 PyObject * obj1 = 0 ;
48006 char * kwnames[] = {
48007 (char *) "self",(char *) "idx", NULL
48008 };
48009
48010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48012 if (!SWIG_IsOK(res1)) {
48013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48014 }
48015 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48016 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48017 if (!SWIG_IsOK(ecode2)) {
48018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48019 }
48020 arg2 = static_cast< size_t >(val2);
48021 {
48022 PyThreadState* __tstate = wxPyBeginAllowThreads();
48023 (arg1)->RemoveGrowableRow(arg2);
48024 wxPyEndAllowThreads(__tstate);
48025 if (PyErr_Occurred()) SWIG_fail;
48026 }
48027 resultobj = SWIG_Py_Void();
48028 return resultobj;
48029 fail:
48030 return NULL;
48031 }
48032
48033
48034 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48035 PyObject *resultobj = 0;
48036 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48037 size_t arg2 ;
48038 int arg3 = (int) 0 ;
48039 void *argp1 = 0 ;
48040 int res1 = 0 ;
48041 size_t val2 ;
48042 int ecode2 = 0 ;
48043 int val3 ;
48044 int ecode3 = 0 ;
48045 PyObject * obj0 = 0 ;
48046 PyObject * obj1 = 0 ;
48047 PyObject * obj2 = 0 ;
48048 char * kwnames[] = {
48049 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48050 };
48051
48052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48054 if (!SWIG_IsOK(res1)) {
48055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48056 }
48057 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48058 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48059 if (!SWIG_IsOK(ecode2)) {
48060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48061 }
48062 arg2 = static_cast< size_t >(val2);
48063 if (obj2) {
48064 ecode3 = SWIG_AsVal_int(obj2, &val3);
48065 if (!SWIG_IsOK(ecode3)) {
48066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48067 }
48068 arg3 = static_cast< int >(val3);
48069 }
48070 {
48071 PyThreadState* __tstate = wxPyBeginAllowThreads();
48072 (arg1)->AddGrowableCol(arg2,arg3);
48073 wxPyEndAllowThreads(__tstate);
48074 if (PyErr_Occurred()) SWIG_fail;
48075 }
48076 resultobj = SWIG_Py_Void();
48077 return resultobj;
48078 fail:
48079 return NULL;
48080 }
48081
48082
48083 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48084 PyObject *resultobj = 0;
48085 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48086 size_t arg2 ;
48087 void *argp1 = 0 ;
48088 int res1 = 0 ;
48089 size_t val2 ;
48090 int ecode2 = 0 ;
48091 PyObject * obj0 = 0 ;
48092 PyObject * obj1 = 0 ;
48093 char * kwnames[] = {
48094 (char *) "self",(char *) "idx", NULL
48095 };
48096
48097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48099 if (!SWIG_IsOK(res1)) {
48100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48101 }
48102 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48103 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48104 if (!SWIG_IsOK(ecode2)) {
48105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48106 }
48107 arg2 = static_cast< size_t >(val2);
48108 {
48109 PyThreadState* __tstate = wxPyBeginAllowThreads();
48110 (arg1)->RemoveGrowableCol(arg2);
48111 wxPyEndAllowThreads(__tstate);
48112 if (PyErr_Occurred()) SWIG_fail;
48113 }
48114 resultobj = SWIG_Py_Void();
48115 return resultobj;
48116 fail:
48117 return NULL;
48118 }
48119
48120
48121 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48122 PyObject *resultobj = 0;
48123 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48124 int arg2 ;
48125 void *argp1 = 0 ;
48126 int res1 = 0 ;
48127 int val2 ;
48128 int ecode2 = 0 ;
48129 PyObject * obj0 = 0 ;
48130 PyObject * obj1 = 0 ;
48131 char * kwnames[] = {
48132 (char *) "self",(char *) "direction", NULL
48133 };
48134
48135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48137 if (!SWIG_IsOK(res1)) {
48138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48139 }
48140 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48141 ecode2 = SWIG_AsVal_int(obj1, &val2);
48142 if (!SWIG_IsOK(ecode2)) {
48143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48144 }
48145 arg2 = static_cast< int >(val2);
48146 {
48147 PyThreadState* __tstate = wxPyBeginAllowThreads();
48148 (arg1)->SetFlexibleDirection(arg2);
48149 wxPyEndAllowThreads(__tstate);
48150 if (PyErr_Occurred()) SWIG_fail;
48151 }
48152 resultobj = SWIG_Py_Void();
48153 return resultobj;
48154 fail:
48155 return NULL;
48156 }
48157
48158
48159 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48160 PyObject *resultobj = 0;
48161 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48162 int result;
48163 void *argp1 = 0 ;
48164 int res1 = 0 ;
48165 PyObject *swig_obj[1] ;
48166
48167 if (!args) SWIG_fail;
48168 swig_obj[0] = args;
48169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48170 if (!SWIG_IsOK(res1)) {
48171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48172 }
48173 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48174 {
48175 PyThreadState* __tstate = wxPyBeginAllowThreads();
48176 result = (int)(arg1)->GetFlexibleDirection();
48177 wxPyEndAllowThreads(__tstate);
48178 if (PyErr_Occurred()) SWIG_fail;
48179 }
48180 resultobj = SWIG_From_int(static_cast< int >(result));
48181 return resultobj;
48182 fail:
48183 return NULL;
48184 }
48185
48186
48187 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48188 PyObject *resultobj = 0;
48189 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48190 wxFlexSizerGrowMode arg2 ;
48191 void *argp1 = 0 ;
48192 int res1 = 0 ;
48193 int val2 ;
48194 int ecode2 = 0 ;
48195 PyObject * obj0 = 0 ;
48196 PyObject * obj1 = 0 ;
48197 char * kwnames[] = {
48198 (char *) "self",(char *) "mode", NULL
48199 };
48200
48201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48203 if (!SWIG_IsOK(res1)) {
48204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48205 }
48206 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48207 ecode2 = SWIG_AsVal_int(obj1, &val2);
48208 if (!SWIG_IsOK(ecode2)) {
48209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48210 }
48211 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48212 {
48213 PyThreadState* __tstate = wxPyBeginAllowThreads();
48214 (arg1)->SetNonFlexibleGrowMode(arg2);
48215 wxPyEndAllowThreads(__tstate);
48216 if (PyErr_Occurred()) SWIG_fail;
48217 }
48218 resultobj = SWIG_Py_Void();
48219 return resultobj;
48220 fail:
48221 return NULL;
48222 }
48223
48224
48225 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48226 PyObject *resultobj = 0;
48227 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48228 wxFlexSizerGrowMode result;
48229 void *argp1 = 0 ;
48230 int res1 = 0 ;
48231 PyObject *swig_obj[1] ;
48232
48233 if (!args) SWIG_fail;
48234 swig_obj[0] = args;
48235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48236 if (!SWIG_IsOK(res1)) {
48237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48238 }
48239 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48240 {
48241 PyThreadState* __tstate = wxPyBeginAllowThreads();
48242 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48243 wxPyEndAllowThreads(__tstate);
48244 if (PyErr_Occurred()) SWIG_fail;
48245 }
48246 resultobj = SWIG_From_int(static_cast< int >(result));
48247 return resultobj;
48248 fail:
48249 return NULL;
48250 }
48251
48252
48253 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48254 PyObject *resultobj = 0;
48255 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48256 wxArrayInt *result = 0 ;
48257 void *argp1 = 0 ;
48258 int res1 = 0 ;
48259 PyObject *swig_obj[1] ;
48260
48261 if (!args) SWIG_fail;
48262 swig_obj[0] = args;
48263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48264 if (!SWIG_IsOK(res1)) {
48265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48266 }
48267 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48268 {
48269 PyThreadState* __tstate = wxPyBeginAllowThreads();
48270 {
48271 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48272 result = (wxArrayInt *) &_result_ref;
48273 }
48274 wxPyEndAllowThreads(__tstate);
48275 if (PyErr_Occurred()) SWIG_fail;
48276 }
48277 {
48278 resultobj = PyList_New(0);
48279 size_t idx;
48280 for (idx = 0; idx < result->GetCount(); idx += 1) {
48281 PyObject* val = PyInt_FromLong( result->Item(idx) );
48282 PyList_Append(resultobj, val);
48283 Py_DECREF(val);
48284 }
48285 }
48286 return resultobj;
48287 fail:
48288 return NULL;
48289 }
48290
48291
48292 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48293 PyObject *resultobj = 0;
48294 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48295 wxArrayInt *result = 0 ;
48296 void *argp1 = 0 ;
48297 int res1 = 0 ;
48298 PyObject *swig_obj[1] ;
48299
48300 if (!args) SWIG_fail;
48301 swig_obj[0] = args;
48302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48303 if (!SWIG_IsOK(res1)) {
48304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48305 }
48306 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48307 {
48308 PyThreadState* __tstate = wxPyBeginAllowThreads();
48309 {
48310 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48311 result = (wxArrayInt *) &_result_ref;
48312 }
48313 wxPyEndAllowThreads(__tstate);
48314 if (PyErr_Occurred()) SWIG_fail;
48315 }
48316 {
48317 resultobj = PyList_New(0);
48318 size_t idx;
48319 for (idx = 0; idx < result->GetCount(); idx += 1) {
48320 PyObject* val = PyInt_FromLong( result->Item(idx) );
48321 PyList_Append(resultobj, val);
48322 Py_DECREF(val);
48323 }
48324 }
48325 return resultobj;
48326 fail:
48327 return NULL;
48328 }
48329
48330
48331 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48332 PyObject *obj;
48333 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48334 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48335 return SWIG_Py_Void();
48336 }
48337
48338 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48339 return SWIG_Python_InitShadowInstance(args);
48340 }
48341
48342 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48343 PyObject *resultobj = 0;
48344 wxStdDialogButtonSizer *result = 0 ;
48345
48346 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48347 {
48348 PyThreadState* __tstate = wxPyBeginAllowThreads();
48349 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48350 wxPyEndAllowThreads(__tstate);
48351 if (PyErr_Occurred()) SWIG_fail;
48352 }
48353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48354 return resultobj;
48355 fail:
48356 return NULL;
48357 }
48358
48359
48360 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48361 PyObject *resultobj = 0;
48362 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48363 wxButton *arg2 = (wxButton *) 0 ;
48364 void *argp1 = 0 ;
48365 int res1 = 0 ;
48366 void *argp2 = 0 ;
48367 int res2 = 0 ;
48368 PyObject * obj0 = 0 ;
48369 PyObject * obj1 = 0 ;
48370 char * kwnames[] = {
48371 (char *) "self",(char *) "button", NULL
48372 };
48373
48374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48376 if (!SWIG_IsOK(res1)) {
48377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48378 }
48379 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48381 if (!SWIG_IsOK(res2)) {
48382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48383 }
48384 arg2 = reinterpret_cast< wxButton * >(argp2);
48385 {
48386 PyThreadState* __tstate = wxPyBeginAllowThreads();
48387 (arg1)->AddButton(arg2);
48388 wxPyEndAllowThreads(__tstate);
48389 if (PyErr_Occurred()) SWIG_fail;
48390 }
48391 resultobj = SWIG_Py_Void();
48392 return resultobj;
48393 fail:
48394 return NULL;
48395 }
48396
48397
48398 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48399 PyObject *resultobj = 0;
48400 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48401 void *argp1 = 0 ;
48402 int res1 = 0 ;
48403 PyObject *swig_obj[1] ;
48404
48405 if (!args) SWIG_fail;
48406 swig_obj[0] = args;
48407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48408 if (!SWIG_IsOK(res1)) {
48409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48410 }
48411 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48412 {
48413 PyThreadState* __tstate = wxPyBeginAllowThreads();
48414 (arg1)->Realize();
48415 wxPyEndAllowThreads(__tstate);
48416 if (PyErr_Occurred()) SWIG_fail;
48417 }
48418 resultobj = SWIG_Py_Void();
48419 return resultobj;
48420 fail:
48421 return NULL;
48422 }
48423
48424
48425 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48426 PyObject *resultobj = 0;
48427 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48428 wxButton *arg2 = (wxButton *) 0 ;
48429 void *argp1 = 0 ;
48430 int res1 = 0 ;
48431 void *argp2 = 0 ;
48432 int res2 = 0 ;
48433 PyObject * obj0 = 0 ;
48434 PyObject * obj1 = 0 ;
48435 char * kwnames[] = {
48436 (char *) "self",(char *) "button", NULL
48437 };
48438
48439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48441 if (!SWIG_IsOK(res1)) {
48442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48443 }
48444 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48445 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48446 if (!SWIG_IsOK(res2)) {
48447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48448 }
48449 arg2 = reinterpret_cast< wxButton * >(argp2);
48450 {
48451 PyThreadState* __tstate = wxPyBeginAllowThreads();
48452 (arg1)->SetAffirmativeButton(arg2);
48453 wxPyEndAllowThreads(__tstate);
48454 if (PyErr_Occurred()) SWIG_fail;
48455 }
48456 resultobj = SWIG_Py_Void();
48457 return resultobj;
48458 fail:
48459 return NULL;
48460 }
48461
48462
48463 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48464 PyObject *resultobj = 0;
48465 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48466 wxButton *arg2 = (wxButton *) 0 ;
48467 void *argp1 = 0 ;
48468 int res1 = 0 ;
48469 void *argp2 = 0 ;
48470 int res2 = 0 ;
48471 PyObject * obj0 = 0 ;
48472 PyObject * obj1 = 0 ;
48473 char * kwnames[] = {
48474 (char *) "self",(char *) "button", NULL
48475 };
48476
48477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48479 if (!SWIG_IsOK(res1)) {
48480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48481 }
48482 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48483 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48484 if (!SWIG_IsOK(res2)) {
48485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48486 }
48487 arg2 = reinterpret_cast< wxButton * >(argp2);
48488 {
48489 PyThreadState* __tstate = wxPyBeginAllowThreads();
48490 (arg1)->SetNegativeButton(arg2);
48491 wxPyEndAllowThreads(__tstate);
48492 if (PyErr_Occurred()) SWIG_fail;
48493 }
48494 resultobj = SWIG_Py_Void();
48495 return resultobj;
48496 fail:
48497 return NULL;
48498 }
48499
48500
48501 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48502 PyObject *resultobj = 0;
48503 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48504 wxButton *arg2 = (wxButton *) 0 ;
48505 void *argp1 = 0 ;
48506 int res1 = 0 ;
48507 void *argp2 = 0 ;
48508 int res2 = 0 ;
48509 PyObject * obj0 = 0 ;
48510 PyObject * obj1 = 0 ;
48511 char * kwnames[] = {
48512 (char *) "self",(char *) "button", NULL
48513 };
48514
48515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48517 if (!SWIG_IsOK(res1)) {
48518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48519 }
48520 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48522 if (!SWIG_IsOK(res2)) {
48523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48524 }
48525 arg2 = reinterpret_cast< wxButton * >(argp2);
48526 {
48527 PyThreadState* __tstate = wxPyBeginAllowThreads();
48528 (arg1)->SetCancelButton(arg2);
48529 wxPyEndAllowThreads(__tstate);
48530 if (PyErr_Occurred()) SWIG_fail;
48531 }
48532 resultobj = SWIG_Py_Void();
48533 return resultobj;
48534 fail:
48535 return NULL;
48536 }
48537
48538
48539 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48540 PyObject *resultobj = 0;
48541 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48542 wxButton *result = 0 ;
48543 void *argp1 = 0 ;
48544 int res1 = 0 ;
48545 PyObject *swig_obj[1] ;
48546
48547 if (!args) SWIG_fail;
48548 swig_obj[0] = args;
48549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48550 if (!SWIG_IsOK(res1)) {
48551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48552 }
48553 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48554 {
48555 PyThreadState* __tstate = wxPyBeginAllowThreads();
48556 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48557 wxPyEndAllowThreads(__tstate);
48558 if (PyErr_Occurred()) SWIG_fail;
48559 }
48560 {
48561 resultobj = wxPyMake_wxObject(result, (bool)0);
48562 }
48563 return resultobj;
48564 fail:
48565 return NULL;
48566 }
48567
48568
48569 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48570 PyObject *resultobj = 0;
48571 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48572 wxButton *result = 0 ;
48573 void *argp1 = 0 ;
48574 int res1 = 0 ;
48575 PyObject *swig_obj[1] ;
48576
48577 if (!args) SWIG_fail;
48578 swig_obj[0] = args;
48579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48580 if (!SWIG_IsOK(res1)) {
48581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48582 }
48583 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48584 {
48585 PyThreadState* __tstate = wxPyBeginAllowThreads();
48586 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48587 wxPyEndAllowThreads(__tstate);
48588 if (PyErr_Occurred()) SWIG_fail;
48589 }
48590 {
48591 resultobj = wxPyMake_wxObject(result, (bool)0);
48592 }
48593 return resultobj;
48594 fail:
48595 return NULL;
48596 }
48597
48598
48599 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48600 PyObject *resultobj = 0;
48601 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48602 wxButton *result = 0 ;
48603 void *argp1 = 0 ;
48604 int res1 = 0 ;
48605 PyObject *swig_obj[1] ;
48606
48607 if (!args) SWIG_fail;
48608 swig_obj[0] = args;
48609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48610 if (!SWIG_IsOK(res1)) {
48611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48612 }
48613 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48614 {
48615 PyThreadState* __tstate = wxPyBeginAllowThreads();
48616 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48617 wxPyEndAllowThreads(__tstate);
48618 if (PyErr_Occurred()) SWIG_fail;
48619 }
48620 {
48621 resultobj = wxPyMake_wxObject(result, (bool)0);
48622 }
48623 return resultobj;
48624 fail:
48625 return NULL;
48626 }
48627
48628
48629 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48630 PyObject *resultobj = 0;
48631 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48632 wxButton *result = 0 ;
48633 void *argp1 = 0 ;
48634 int res1 = 0 ;
48635 PyObject *swig_obj[1] ;
48636
48637 if (!args) SWIG_fail;
48638 swig_obj[0] = args;
48639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48640 if (!SWIG_IsOK(res1)) {
48641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48642 }
48643 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48644 {
48645 PyThreadState* __tstate = wxPyBeginAllowThreads();
48646 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48647 wxPyEndAllowThreads(__tstate);
48648 if (PyErr_Occurred()) SWIG_fail;
48649 }
48650 {
48651 resultobj = wxPyMake_wxObject(result, (bool)0);
48652 }
48653 return resultobj;
48654 fail:
48655 return NULL;
48656 }
48657
48658
48659 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48660 PyObject *resultobj = 0;
48661 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48662 wxButton *result = 0 ;
48663 void *argp1 = 0 ;
48664 int res1 = 0 ;
48665 PyObject *swig_obj[1] ;
48666
48667 if (!args) SWIG_fail;
48668 swig_obj[0] = args;
48669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48670 if (!SWIG_IsOK(res1)) {
48671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48672 }
48673 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48674 {
48675 PyThreadState* __tstate = wxPyBeginAllowThreads();
48676 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48677 wxPyEndAllowThreads(__tstate);
48678 if (PyErr_Occurred()) SWIG_fail;
48679 }
48680 {
48681 resultobj = wxPyMake_wxObject(result, (bool)0);
48682 }
48683 return resultobj;
48684 fail:
48685 return NULL;
48686 }
48687
48688
48689 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48690 PyObject *obj;
48691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48692 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48693 return SWIG_Py_Void();
48694 }
48695
48696 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48697 return SWIG_Python_InitShadowInstance(args);
48698 }
48699
48700 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48701 PyObject *resultobj = 0;
48702 int arg1 = (int) 0 ;
48703 int arg2 = (int) 0 ;
48704 wxGBPosition *result = 0 ;
48705 int val1 ;
48706 int ecode1 = 0 ;
48707 int val2 ;
48708 int ecode2 = 0 ;
48709 PyObject * obj0 = 0 ;
48710 PyObject * obj1 = 0 ;
48711 char * kwnames[] = {
48712 (char *) "row",(char *) "col", NULL
48713 };
48714
48715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48716 if (obj0) {
48717 ecode1 = SWIG_AsVal_int(obj0, &val1);
48718 if (!SWIG_IsOK(ecode1)) {
48719 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48720 }
48721 arg1 = static_cast< int >(val1);
48722 }
48723 if (obj1) {
48724 ecode2 = SWIG_AsVal_int(obj1, &val2);
48725 if (!SWIG_IsOK(ecode2)) {
48726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48727 }
48728 arg2 = static_cast< int >(val2);
48729 }
48730 {
48731 PyThreadState* __tstate = wxPyBeginAllowThreads();
48732 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48733 wxPyEndAllowThreads(__tstate);
48734 if (PyErr_Occurred()) SWIG_fail;
48735 }
48736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48737 return resultobj;
48738 fail:
48739 return NULL;
48740 }
48741
48742
48743 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48744 PyObject *resultobj = 0;
48745 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48746 void *argp1 = 0 ;
48747 int res1 = 0 ;
48748 PyObject *swig_obj[1] ;
48749
48750 if (!args) SWIG_fail;
48751 swig_obj[0] = args;
48752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48753 if (!SWIG_IsOK(res1)) {
48754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48755 }
48756 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48757 {
48758 PyThreadState* __tstate = wxPyBeginAllowThreads();
48759 delete arg1;
48760
48761 wxPyEndAllowThreads(__tstate);
48762 if (PyErr_Occurred()) SWIG_fail;
48763 }
48764 resultobj = SWIG_Py_Void();
48765 return resultobj;
48766 fail:
48767 return NULL;
48768 }
48769
48770
48771 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48772 PyObject *resultobj = 0;
48773 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48774 int result;
48775 void *argp1 = 0 ;
48776 int res1 = 0 ;
48777 PyObject *swig_obj[1] ;
48778
48779 if (!args) SWIG_fail;
48780 swig_obj[0] = args;
48781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48782 if (!SWIG_IsOK(res1)) {
48783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48784 }
48785 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48786 {
48787 PyThreadState* __tstate = wxPyBeginAllowThreads();
48788 result = (int)((wxGBPosition const *)arg1)->GetRow();
48789 wxPyEndAllowThreads(__tstate);
48790 if (PyErr_Occurred()) SWIG_fail;
48791 }
48792 resultobj = SWIG_From_int(static_cast< int >(result));
48793 return resultobj;
48794 fail:
48795 return NULL;
48796 }
48797
48798
48799 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48800 PyObject *resultobj = 0;
48801 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48802 int result;
48803 void *argp1 = 0 ;
48804 int res1 = 0 ;
48805 PyObject *swig_obj[1] ;
48806
48807 if (!args) SWIG_fail;
48808 swig_obj[0] = args;
48809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48810 if (!SWIG_IsOK(res1)) {
48811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48812 }
48813 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48814 {
48815 PyThreadState* __tstate = wxPyBeginAllowThreads();
48816 result = (int)((wxGBPosition const *)arg1)->GetCol();
48817 wxPyEndAllowThreads(__tstate);
48818 if (PyErr_Occurred()) SWIG_fail;
48819 }
48820 resultobj = SWIG_From_int(static_cast< int >(result));
48821 return resultobj;
48822 fail:
48823 return NULL;
48824 }
48825
48826
48827 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48828 PyObject *resultobj = 0;
48829 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48830 int arg2 ;
48831 void *argp1 = 0 ;
48832 int res1 = 0 ;
48833 int val2 ;
48834 int ecode2 = 0 ;
48835 PyObject * obj0 = 0 ;
48836 PyObject * obj1 = 0 ;
48837 char * kwnames[] = {
48838 (char *) "self",(char *) "row", NULL
48839 };
48840
48841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48843 if (!SWIG_IsOK(res1)) {
48844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48845 }
48846 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48847 ecode2 = SWIG_AsVal_int(obj1, &val2);
48848 if (!SWIG_IsOK(ecode2)) {
48849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48850 }
48851 arg2 = static_cast< int >(val2);
48852 {
48853 PyThreadState* __tstate = wxPyBeginAllowThreads();
48854 (arg1)->SetRow(arg2);
48855 wxPyEndAllowThreads(__tstate);
48856 if (PyErr_Occurred()) SWIG_fail;
48857 }
48858 resultobj = SWIG_Py_Void();
48859 return resultobj;
48860 fail:
48861 return NULL;
48862 }
48863
48864
48865 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48866 PyObject *resultobj = 0;
48867 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48868 int arg2 ;
48869 void *argp1 = 0 ;
48870 int res1 = 0 ;
48871 int val2 ;
48872 int ecode2 = 0 ;
48873 PyObject * obj0 = 0 ;
48874 PyObject * obj1 = 0 ;
48875 char * kwnames[] = {
48876 (char *) "self",(char *) "col", NULL
48877 };
48878
48879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48881 if (!SWIG_IsOK(res1)) {
48882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48883 }
48884 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48885 ecode2 = SWIG_AsVal_int(obj1, &val2);
48886 if (!SWIG_IsOK(ecode2)) {
48887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48888 }
48889 arg2 = static_cast< int >(val2);
48890 {
48891 PyThreadState* __tstate = wxPyBeginAllowThreads();
48892 (arg1)->SetCol(arg2);
48893 wxPyEndAllowThreads(__tstate);
48894 if (PyErr_Occurred()) SWIG_fail;
48895 }
48896 resultobj = SWIG_Py_Void();
48897 return resultobj;
48898 fail:
48899 return NULL;
48900 }
48901
48902
48903 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48904 PyObject *resultobj = 0;
48905 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48906 PyObject *arg2 = (PyObject *) 0 ;
48907 bool result;
48908 void *argp1 = 0 ;
48909 int res1 = 0 ;
48910 PyObject * obj0 = 0 ;
48911 PyObject * obj1 = 0 ;
48912 char * kwnames[] = {
48913 (char *) "self",(char *) "other", NULL
48914 };
48915
48916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48918 if (!SWIG_IsOK(res1)) {
48919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48920 }
48921 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48922 arg2 = obj1;
48923 {
48924 result = (bool)wxGBPosition___eq__(arg1,arg2);
48925 if (PyErr_Occurred()) SWIG_fail;
48926 }
48927 {
48928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48929 }
48930 return resultobj;
48931 fail:
48932 return NULL;
48933 }
48934
48935
48936 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48937 PyObject *resultobj = 0;
48938 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48939 PyObject *arg2 = (PyObject *) 0 ;
48940 bool result;
48941 void *argp1 = 0 ;
48942 int res1 = 0 ;
48943 PyObject * obj0 = 0 ;
48944 PyObject * obj1 = 0 ;
48945 char * kwnames[] = {
48946 (char *) "self",(char *) "other", NULL
48947 };
48948
48949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48951 if (!SWIG_IsOK(res1)) {
48952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48953 }
48954 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48955 arg2 = obj1;
48956 {
48957 result = (bool)wxGBPosition___ne__(arg1,arg2);
48958 if (PyErr_Occurred()) SWIG_fail;
48959 }
48960 {
48961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48962 }
48963 return resultobj;
48964 fail:
48965 return NULL;
48966 }
48967
48968
48969 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48970 PyObject *resultobj = 0;
48971 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48972 int arg2 = (int) 0 ;
48973 int arg3 = (int) 0 ;
48974 void *argp1 = 0 ;
48975 int res1 = 0 ;
48976 int val2 ;
48977 int ecode2 = 0 ;
48978 int val3 ;
48979 int ecode3 = 0 ;
48980 PyObject * obj0 = 0 ;
48981 PyObject * obj1 = 0 ;
48982 PyObject * obj2 = 0 ;
48983 char * kwnames[] = {
48984 (char *) "self",(char *) "row",(char *) "col", NULL
48985 };
48986
48987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48989 if (!SWIG_IsOK(res1)) {
48990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48991 }
48992 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48993 if (obj1) {
48994 ecode2 = SWIG_AsVal_int(obj1, &val2);
48995 if (!SWIG_IsOK(ecode2)) {
48996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48997 }
48998 arg2 = static_cast< int >(val2);
48999 }
49000 if (obj2) {
49001 ecode3 = SWIG_AsVal_int(obj2, &val3);
49002 if (!SWIG_IsOK(ecode3)) {
49003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49004 }
49005 arg3 = static_cast< int >(val3);
49006 }
49007 {
49008 PyThreadState* __tstate = wxPyBeginAllowThreads();
49009 wxGBPosition_Set(arg1,arg2,arg3);
49010 wxPyEndAllowThreads(__tstate);
49011 if (PyErr_Occurred()) SWIG_fail;
49012 }
49013 resultobj = SWIG_Py_Void();
49014 return resultobj;
49015 fail:
49016 return NULL;
49017 }
49018
49019
49020 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49021 PyObject *resultobj = 0;
49022 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49023 PyObject *result = 0 ;
49024 void *argp1 = 0 ;
49025 int res1 = 0 ;
49026 PyObject *swig_obj[1] ;
49027
49028 if (!args) SWIG_fail;
49029 swig_obj[0] = args;
49030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49031 if (!SWIG_IsOK(res1)) {
49032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49033 }
49034 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49035 {
49036 PyThreadState* __tstate = wxPyBeginAllowThreads();
49037 result = (PyObject *)wxGBPosition_Get(arg1);
49038 wxPyEndAllowThreads(__tstate);
49039 if (PyErr_Occurred()) SWIG_fail;
49040 }
49041 resultobj = result;
49042 return resultobj;
49043 fail:
49044 return NULL;
49045 }
49046
49047
49048 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49049 PyObject *obj;
49050 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49051 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49052 return SWIG_Py_Void();
49053 }
49054
49055 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49056 return SWIG_Python_InitShadowInstance(args);
49057 }
49058
49059 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49060 PyObject *resultobj = 0;
49061 int arg1 = (int) 1 ;
49062 int arg2 = (int) 1 ;
49063 wxGBSpan *result = 0 ;
49064 int val1 ;
49065 int ecode1 = 0 ;
49066 int val2 ;
49067 int ecode2 = 0 ;
49068 PyObject * obj0 = 0 ;
49069 PyObject * obj1 = 0 ;
49070 char * kwnames[] = {
49071 (char *) "rowspan",(char *) "colspan", NULL
49072 };
49073
49074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49075 if (obj0) {
49076 ecode1 = SWIG_AsVal_int(obj0, &val1);
49077 if (!SWIG_IsOK(ecode1)) {
49078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49079 }
49080 arg1 = static_cast< int >(val1);
49081 }
49082 if (obj1) {
49083 ecode2 = SWIG_AsVal_int(obj1, &val2);
49084 if (!SWIG_IsOK(ecode2)) {
49085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49086 }
49087 arg2 = static_cast< int >(val2);
49088 }
49089 {
49090 PyThreadState* __tstate = wxPyBeginAllowThreads();
49091 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49092 wxPyEndAllowThreads(__tstate);
49093 if (PyErr_Occurred()) SWIG_fail;
49094 }
49095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49096 return resultobj;
49097 fail:
49098 return NULL;
49099 }
49100
49101
49102 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49103 PyObject *resultobj = 0;
49104 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49105 void *argp1 = 0 ;
49106 int res1 = 0 ;
49107 PyObject *swig_obj[1] ;
49108
49109 if (!args) SWIG_fail;
49110 swig_obj[0] = args;
49111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49112 if (!SWIG_IsOK(res1)) {
49113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49114 }
49115 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49116 {
49117 PyThreadState* __tstate = wxPyBeginAllowThreads();
49118 delete arg1;
49119
49120 wxPyEndAllowThreads(__tstate);
49121 if (PyErr_Occurred()) SWIG_fail;
49122 }
49123 resultobj = SWIG_Py_Void();
49124 return resultobj;
49125 fail:
49126 return NULL;
49127 }
49128
49129
49130 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49131 PyObject *resultobj = 0;
49132 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49133 int result;
49134 void *argp1 = 0 ;
49135 int res1 = 0 ;
49136 PyObject *swig_obj[1] ;
49137
49138 if (!args) SWIG_fail;
49139 swig_obj[0] = args;
49140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49141 if (!SWIG_IsOK(res1)) {
49142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49143 }
49144 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49145 {
49146 PyThreadState* __tstate = wxPyBeginAllowThreads();
49147 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49148 wxPyEndAllowThreads(__tstate);
49149 if (PyErr_Occurred()) SWIG_fail;
49150 }
49151 resultobj = SWIG_From_int(static_cast< int >(result));
49152 return resultobj;
49153 fail:
49154 return NULL;
49155 }
49156
49157
49158 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49159 PyObject *resultobj = 0;
49160 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49161 int result;
49162 void *argp1 = 0 ;
49163 int res1 = 0 ;
49164 PyObject *swig_obj[1] ;
49165
49166 if (!args) SWIG_fail;
49167 swig_obj[0] = args;
49168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49169 if (!SWIG_IsOK(res1)) {
49170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49171 }
49172 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49173 {
49174 PyThreadState* __tstate = wxPyBeginAllowThreads();
49175 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49176 wxPyEndAllowThreads(__tstate);
49177 if (PyErr_Occurred()) SWIG_fail;
49178 }
49179 resultobj = SWIG_From_int(static_cast< int >(result));
49180 return resultobj;
49181 fail:
49182 return NULL;
49183 }
49184
49185
49186 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49187 PyObject *resultobj = 0;
49188 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49189 int arg2 ;
49190 void *argp1 = 0 ;
49191 int res1 = 0 ;
49192 int val2 ;
49193 int ecode2 = 0 ;
49194 PyObject * obj0 = 0 ;
49195 PyObject * obj1 = 0 ;
49196 char * kwnames[] = {
49197 (char *) "self",(char *) "rowspan", NULL
49198 };
49199
49200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49202 if (!SWIG_IsOK(res1)) {
49203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49204 }
49205 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49206 ecode2 = SWIG_AsVal_int(obj1, &val2);
49207 if (!SWIG_IsOK(ecode2)) {
49208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49209 }
49210 arg2 = static_cast< int >(val2);
49211 {
49212 PyThreadState* __tstate = wxPyBeginAllowThreads();
49213 (arg1)->SetRowspan(arg2);
49214 wxPyEndAllowThreads(__tstate);
49215 if (PyErr_Occurred()) SWIG_fail;
49216 }
49217 resultobj = SWIG_Py_Void();
49218 return resultobj;
49219 fail:
49220 return NULL;
49221 }
49222
49223
49224 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49225 PyObject *resultobj = 0;
49226 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49227 int arg2 ;
49228 void *argp1 = 0 ;
49229 int res1 = 0 ;
49230 int val2 ;
49231 int ecode2 = 0 ;
49232 PyObject * obj0 = 0 ;
49233 PyObject * obj1 = 0 ;
49234 char * kwnames[] = {
49235 (char *) "self",(char *) "colspan", NULL
49236 };
49237
49238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49240 if (!SWIG_IsOK(res1)) {
49241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49242 }
49243 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49244 ecode2 = SWIG_AsVal_int(obj1, &val2);
49245 if (!SWIG_IsOK(ecode2)) {
49246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49247 }
49248 arg2 = static_cast< int >(val2);
49249 {
49250 PyThreadState* __tstate = wxPyBeginAllowThreads();
49251 (arg1)->SetColspan(arg2);
49252 wxPyEndAllowThreads(__tstate);
49253 if (PyErr_Occurred()) SWIG_fail;
49254 }
49255 resultobj = SWIG_Py_Void();
49256 return resultobj;
49257 fail:
49258 return NULL;
49259 }
49260
49261
49262 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49263 PyObject *resultobj = 0;
49264 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49265 PyObject *arg2 = (PyObject *) 0 ;
49266 bool result;
49267 void *argp1 = 0 ;
49268 int res1 = 0 ;
49269 PyObject * obj0 = 0 ;
49270 PyObject * obj1 = 0 ;
49271 char * kwnames[] = {
49272 (char *) "self",(char *) "other", NULL
49273 };
49274
49275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49277 if (!SWIG_IsOK(res1)) {
49278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49279 }
49280 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49281 arg2 = obj1;
49282 {
49283 result = (bool)wxGBSpan___eq__(arg1,arg2);
49284 if (PyErr_Occurred()) SWIG_fail;
49285 }
49286 {
49287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49288 }
49289 return resultobj;
49290 fail:
49291 return NULL;
49292 }
49293
49294
49295 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49296 PyObject *resultobj = 0;
49297 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49298 PyObject *arg2 = (PyObject *) 0 ;
49299 bool result;
49300 void *argp1 = 0 ;
49301 int res1 = 0 ;
49302 PyObject * obj0 = 0 ;
49303 PyObject * obj1 = 0 ;
49304 char * kwnames[] = {
49305 (char *) "self",(char *) "other", NULL
49306 };
49307
49308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49310 if (!SWIG_IsOK(res1)) {
49311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49312 }
49313 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49314 arg2 = obj1;
49315 {
49316 result = (bool)wxGBSpan___ne__(arg1,arg2);
49317 if (PyErr_Occurred()) SWIG_fail;
49318 }
49319 {
49320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49321 }
49322 return resultobj;
49323 fail:
49324 return NULL;
49325 }
49326
49327
49328 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49329 PyObject *resultobj = 0;
49330 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49331 int arg2 = (int) 1 ;
49332 int arg3 = (int) 1 ;
49333 void *argp1 = 0 ;
49334 int res1 = 0 ;
49335 int val2 ;
49336 int ecode2 = 0 ;
49337 int val3 ;
49338 int ecode3 = 0 ;
49339 PyObject * obj0 = 0 ;
49340 PyObject * obj1 = 0 ;
49341 PyObject * obj2 = 0 ;
49342 char * kwnames[] = {
49343 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49344 };
49345
49346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49348 if (!SWIG_IsOK(res1)) {
49349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49350 }
49351 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49352 if (obj1) {
49353 ecode2 = SWIG_AsVal_int(obj1, &val2);
49354 if (!SWIG_IsOK(ecode2)) {
49355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49356 }
49357 arg2 = static_cast< int >(val2);
49358 }
49359 if (obj2) {
49360 ecode3 = SWIG_AsVal_int(obj2, &val3);
49361 if (!SWIG_IsOK(ecode3)) {
49362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49363 }
49364 arg3 = static_cast< int >(val3);
49365 }
49366 {
49367 PyThreadState* __tstate = wxPyBeginAllowThreads();
49368 wxGBSpan_Set(arg1,arg2,arg3);
49369 wxPyEndAllowThreads(__tstate);
49370 if (PyErr_Occurred()) SWIG_fail;
49371 }
49372 resultobj = SWIG_Py_Void();
49373 return resultobj;
49374 fail:
49375 return NULL;
49376 }
49377
49378
49379 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49380 PyObject *resultobj = 0;
49381 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49382 PyObject *result = 0 ;
49383 void *argp1 = 0 ;
49384 int res1 = 0 ;
49385 PyObject *swig_obj[1] ;
49386
49387 if (!args) SWIG_fail;
49388 swig_obj[0] = args;
49389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49390 if (!SWIG_IsOK(res1)) {
49391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49392 }
49393 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49394 {
49395 PyThreadState* __tstate = wxPyBeginAllowThreads();
49396 result = (PyObject *)wxGBSpan_Get(arg1);
49397 wxPyEndAllowThreads(__tstate);
49398 if (PyErr_Occurred()) SWIG_fail;
49399 }
49400 resultobj = result;
49401 return resultobj;
49402 fail:
49403 return NULL;
49404 }
49405
49406
49407 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49408 PyObject *obj;
49409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49410 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49411 return SWIG_Py_Void();
49412 }
49413
49414 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49415 return SWIG_Python_InitShadowInstance(args);
49416 }
49417
49418 SWIGINTERN int DefaultSpan_set(PyObject *) {
49419 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49420 return 1;
49421 }
49422
49423
49424 SWIGINTERN PyObject *DefaultSpan_get(void) {
49425 PyObject *pyobj = 0;
49426
49427 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49428 return pyobj;
49429 }
49430
49431
49432 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49433 PyObject *resultobj = 0;
49434 wxGBSizerItem *result = 0 ;
49435
49436 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49437 {
49438 PyThreadState* __tstate = wxPyBeginAllowThreads();
49439 result = (wxGBSizerItem *)new wxGBSizerItem();
49440 wxPyEndAllowThreads(__tstate);
49441 if (PyErr_Occurred()) SWIG_fail;
49442 }
49443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49444 return resultobj;
49445 fail:
49446 return NULL;
49447 }
49448
49449
49450 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49451 PyObject *resultobj = 0;
49452 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49453 void *argp1 = 0 ;
49454 int res1 = 0 ;
49455 PyObject *swig_obj[1] ;
49456
49457 if (!args) SWIG_fail;
49458 swig_obj[0] = args;
49459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49460 if (!SWIG_IsOK(res1)) {
49461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49462 }
49463 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49464 {
49465 PyThreadState* __tstate = wxPyBeginAllowThreads();
49466 delete arg1;
49467
49468 wxPyEndAllowThreads(__tstate);
49469 if (PyErr_Occurred()) SWIG_fail;
49470 }
49471 resultobj = SWIG_Py_Void();
49472 return resultobj;
49473 fail:
49474 return NULL;
49475 }
49476
49477
49478 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49479 PyObject *resultobj = 0;
49480 wxWindow *arg1 = (wxWindow *) 0 ;
49481 wxGBPosition *arg2 = 0 ;
49482 wxGBSpan *arg3 = 0 ;
49483 int arg4 ;
49484 int arg5 ;
49485 PyObject *arg6 = (PyObject *) NULL ;
49486 wxGBSizerItem *result = 0 ;
49487 void *argp1 = 0 ;
49488 int res1 = 0 ;
49489 wxGBPosition temp2 ;
49490 wxGBSpan temp3 ;
49491 int val4 ;
49492 int ecode4 = 0 ;
49493 int val5 ;
49494 int ecode5 = 0 ;
49495 PyObject * obj0 = 0 ;
49496 PyObject * obj1 = 0 ;
49497 PyObject * obj2 = 0 ;
49498 PyObject * obj3 = 0 ;
49499 PyObject * obj4 = 0 ;
49500 PyObject * obj5 = 0 ;
49501 char * kwnames[] = {
49502 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49503 };
49504
49505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49507 if (!SWIG_IsOK(res1)) {
49508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49509 }
49510 arg1 = reinterpret_cast< wxWindow * >(argp1);
49511 {
49512 arg2 = &temp2;
49513 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49514 }
49515 {
49516 arg3 = &temp3;
49517 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49518 }
49519 ecode4 = SWIG_AsVal_int(obj3, &val4);
49520 if (!SWIG_IsOK(ecode4)) {
49521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49522 }
49523 arg4 = static_cast< int >(val4);
49524 ecode5 = SWIG_AsVal_int(obj4, &val5);
49525 if (!SWIG_IsOK(ecode5)) {
49526 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49527 }
49528 arg5 = static_cast< int >(val5);
49529 if (obj5) {
49530 arg6 = obj5;
49531 }
49532 {
49533 PyThreadState* __tstate = wxPyBeginAllowThreads();
49534 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49535 wxPyEndAllowThreads(__tstate);
49536 if (PyErr_Occurred()) SWIG_fail;
49537 }
49538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49539 return resultobj;
49540 fail:
49541 return NULL;
49542 }
49543
49544
49545 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49546 PyObject *resultobj = 0;
49547 wxSizer *arg1 = (wxSizer *) 0 ;
49548 wxGBPosition *arg2 = 0 ;
49549 wxGBSpan *arg3 = 0 ;
49550 int arg4 ;
49551 int arg5 ;
49552 PyObject *arg6 = (PyObject *) NULL ;
49553 wxGBSizerItem *result = 0 ;
49554 int res1 = 0 ;
49555 wxGBPosition temp2 ;
49556 wxGBSpan temp3 ;
49557 int val4 ;
49558 int ecode4 = 0 ;
49559 int val5 ;
49560 int ecode5 = 0 ;
49561 PyObject * obj0 = 0 ;
49562 PyObject * obj1 = 0 ;
49563 PyObject * obj2 = 0 ;
49564 PyObject * obj3 = 0 ;
49565 PyObject * obj4 = 0 ;
49566 PyObject * obj5 = 0 ;
49567 char * kwnames[] = {
49568 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49569 };
49570
49571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49572 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49573 if (!SWIG_IsOK(res1)) {
49574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49575 }
49576 {
49577 arg2 = &temp2;
49578 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49579 }
49580 {
49581 arg3 = &temp3;
49582 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49583 }
49584 ecode4 = SWIG_AsVal_int(obj3, &val4);
49585 if (!SWIG_IsOK(ecode4)) {
49586 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49587 }
49588 arg4 = static_cast< int >(val4);
49589 ecode5 = SWIG_AsVal_int(obj4, &val5);
49590 if (!SWIG_IsOK(ecode5)) {
49591 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49592 }
49593 arg5 = static_cast< int >(val5);
49594 if (obj5) {
49595 arg6 = obj5;
49596 }
49597 {
49598 PyThreadState* __tstate = wxPyBeginAllowThreads();
49599 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49600 wxPyEndAllowThreads(__tstate);
49601 if (PyErr_Occurred()) SWIG_fail;
49602 }
49603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49604 return resultobj;
49605 fail:
49606 return NULL;
49607 }
49608
49609
49610 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49611 PyObject *resultobj = 0;
49612 int arg1 ;
49613 int arg2 ;
49614 wxGBPosition *arg3 = 0 ;
49615 wxGBSpan *arg4 = 0 ;
49616 int arg5 ;
49617 int arg6 ;
49618 PyObject *arg7 = (PyObject *) NULL ;
49619 wxGBSizerItem *result = 0 ;
49620 int val1 ;
49621 int ecode1 = 0 ;
49622 int val2 ;
49623 int ecode2 = 0 ;
49624 wxGBPosition temp3 ;
49625 wxGBSpan temp4 ;
49626 int val5 ;
49627 int ecode5 = 0 ;
49628 int val6 ;
49629 int ecode6 = 0 ;
49630 PyObject * obj0 = 0 ;
49631 PyObject * obj1 = 0 ;
49632 PyObject * obj2 = 0 ;
49633 PyObject * obj3 = 0 ;
49634 PyObject * obj4 = 0 ;
49635 PyObject * obj5 = 0 ;
49636 PyObject * obj6 = 0 ;
49637 char * kwnames[] = {
49638 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49639 };
49640
49641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49642 ecode1 = SWIG_AsVal_int(obj0, &val1);
49643 if (!SWIG_IsOK(ecode1)) {
49644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49645 }
49646 arg1 = static_cast< int >(val1);
49647 ecode2 = SWIG_AsVal_int(obj1, &val2);
49648 if (!SWIG_IsOK(ecode2)) {
49649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49650 }
49651 arg2 = static_cast< int >(val2);
49652 {
49653 arg3 = &temp3;
49654 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49655 }
49656 {
49657 arg4 = &temp4;
49658 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49659 }
49660 ecode5 = SWIG_AsVal_int(obj4, &val5);
49661 if (!SWIG_IsOK(ecode5)) {
49662 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49663 }
49664 arg5 = static_cast< int >(val5);
49665 ecode6 = SWIG_AsVal_int(obj5, &val6);
49666 if (!SWIG_IsOK(ecode6)) {
49667 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49668 }
49669 arg6 = static_cast< int >(val6);
49670 if (obj6) {
49671 arg7 = obj6;
49672 }
49673 {
49674 PyThreadState* __tstate = wxPyBeginAllowThreads();
49675 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49676 wxPyEndAllowThreads(__tstate);
49677 if (PyErr_Occurred()) SWIG_fail;
49678 }
49679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49680 return resultobj;
49681 fail:
49682 return NULL;
49683 }
49684
49685
49686 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49687 PyObject *resultobj = 0;
49688 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49689 wxGBPosition result;
49690 void *argp1 = 0 ;
49691 int res1 = 0 ;
49692 PyObject *swig_obj[1] ;
49693
49694 if (!args) SWIG_fail;
49695 swig_obj[0] = args;
49696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49697 if (!SWIG_IsOK(res1)) {
49698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49699 }
49700 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49701 {
49702 PyThreadState* __tstate = wxPyBeginAllowThreads();
49703 result = ((wxGBSizerItem const *)arg1)->GetPos();
49704 wxPyEndAllowThreads(__tstate);
49705 if (PyErr_Occurred()) SWIG_fail;
49706 }
49707 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49708 return resultobj;
49709 fail:
49710 return NULL;
49711 }
49712
49713
49714 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49715 PyObject *resultobj = 0;
49716 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49717 wxGBSpan result;
49718 void *argp1 = 0 ;
49719 int res1 = 0 ;
49720 PyObject *swig_obj[1] ;
49721
49722 if (!args) SWIG_fail;
49723 swig_obj[0] = args;
49724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49725 if (!SWIG_IsOK(res1)) {
49726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49727 }
49728 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49729 {
49730 PyThreadState* __tstate = wxPyBeginAllowThreads();
49731 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49732 wxPyEndAllowThreads(__tstate);
49733 if (PyErr_Occurred()) SWIG_fail;
49734 }
49735 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49736 return resultobj;
49737 fail:
49738 return NULL;
49739 }
49740
49741
49742 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49743 PyObject *resultobj = 0;
49744 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49745 wxGBPosition *arg2 = 0 ;
49746 bool result;
49747 void *argp1 = 0 ;
49748 int res1 = 0 ;
49749 wxGBPosition temp2 ;
49750 PyObject * obj0 = 0 ;
49751 PyObject * obj1 = 0 ;
49752 char * kwnames[] = {
49753 (char *) "self",(char *) "pos", NULL
49754 };
49755
49756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49758 if (!SWIG_IsOK(res1)) {
49759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49760 }
49761 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49762 {
49763 arg2 = &temp2;
49764 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49765 }
49766 {
49767 PyThreadState* __tstate = wxPyBeginAllowThreads();
49768 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49769 wxPyEndAllowThreads(__tstate);
49770 if (PyErr_Occurred()) SWIG_fail;
49771 }
49772 {
49773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49774 }
49775 return resultobj;
49776 fail:
49777 return NULL;
49778 }
49779
49780
49781 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49782 PyObject *resultobj = 0;
49783 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49784 wxGBSpan *arg2 = 0 ;
49785 bool result;
49786 void *argp1 = 0 ;
49787 int res1 = 0 ;
49788 wxGBSpan temp2 ;
49789 PyObject * obj0 = 0 ;
49790 PyObject * obj1 = 0 ;
49791 char * kwnames[] = {
49792 (char *) "self",(char *) "span", NULL
49793 };
49794
49795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49797 if (!SWIG_IsOK(res1)) {
49798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49799 }
49800 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49801 {
49802 arg2 = &temp2;
49803 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49804 }
49805 {
49806 PyThreadState* __tstate = wxPyBeginAllowThreads();
49807 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49808 wxPyEndAllowThreads(__tstate);
49809 if (PyErr_Occurred()) SWIG_fail;
49810 }
49811 {
49812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49813 }
49814 return resultobj;
49815 fail:
49816 return NULL;
49817 }
49818
49819
49820 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49821 PyObject *resultobj = 0;
49822 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49823 wxGBSizerItem *arg2 = 0 ;
49824 bool result;
49825 void *argp1 = 0 ;
49826 int res1 = 0 ;
49827 void *argp2 = 0 ;
49828 int res2 = 0 ;
49829 PyObject * obj0 = 0 ;
49830 PyObject * obj1 = 0 ;
49831 char * kwnames[] = {
49832 (char *) "self",(char *) "other", NULL
49833 };
49834
49835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49837 if (!SWIG_IsOK(res1)) {
49838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49839 }
49840 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49841 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49842 if (!SWIG_IsOK(res2)) {
49843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49844 }
49845 if (!argp2) {
49846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49847 }
49848 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49849 {
49850 PyThreadState* __tstate = wxPyBeginAllowThreads();
49851 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49852 wxPyEndAllowThreads(__tstate);
49853 if (PyErr_Occurred()) SWIG_fail;
49854 }
49855 {
49856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49857 }
49858 return resultobj;
49859 fail:
49860 return NULL;
49861 }
49862
49863
49864 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49865 PyObject *resultobj = 0;
49866 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49867 wxGBPosition *arg2 = 0 ;
49868 wxGBSpan *arg3 = 0 ;
49869 bool result;
49870 void *argp1 = 0 ;
49871 int res1 = 0 ;
49872 wxGBPosition temp2 ;
49873 wxGBSpan temp3 ;
49874 PyObject * obj0 = 0 ;
49875 PyObject * obj1 = 0 ;
49876 PyObject * obj2 = 0 ;
49877 char * kwnames[] = {
49878 (char *) "self",(char *) "pos",(char *) "span", NULL
49879 };
49880
49881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49883 if (!SWIG_IsOK(res1)) {
49884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49885 }
49886 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49887 {
49888 arg2 = &temp2;
49889 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49890 }
49891 {
49892 arg3 = &temp3;
49893 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49894 }
49895 {
49896 PyThreadState* __tstate = wxPyBeginAllowThreads();
49897 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49898 wxPyEndAllowThreads(__tstate);
49899 if (PyErr_Occurred()) SWIG_fail;
49900 }
49901 {
49902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49903 }
49904 return resultobj;
49905 fail:
49906 return NULL;
49907 }
49908
49909
49910 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49911 PyObject *resultobj = 0;
49912 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49913 wxGBPosition result;
49914 void *argp1 = 0 ;
49915 int res1 = 0 ;
49916 PyObject *swig_obj[1] ;
49917
49918 if (!args) SWIG_fail;
49919 swig_obj[0] = args;
49920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49921 if (!SWIG_IsOK(res1)) {
49922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49923 }
49924 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49925 {
49926 PyThreadState* __tstate = wxPyBeginAllowThreads();
49927 result = wxGBSizerItem_GetEndPos(arg1);
49928 wxPyEndAllowThreads(__tstate);
49929 if (PyErr_Occurred()) SWIG_fail;
49930 }
49931 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49932 return resultobj;
49933 fail:
49934 return NULL;
49935 }
49936
49937
49938 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49939 PyObject *resultobj = 0;
49940 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49941 wxGridBagSizer *result = 0 ;
49942 void *argp1 = 0 ;
49943 int res1 = 0 ;
49944 PyObject *swig_obj[1] ;
49945
49946 if (!args) SWIG_fail;
49947 swig_obj[0] = args;
49948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49949 if (!SWIG_IsOK(res1)) {
49950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49951 }
49952 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49953 {
49954 PyThreadState* __tstate = wxPyBeginAllowThreads();
49955 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49956 wxPyEndAllowThreads(__tstate);
49957 if (PyErr_Occurred()) SWIG_fail;
49958 }
49959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49960 return resultobj;
49961 fail:
49962 return NULL;
49963 }
49964
49965
49966 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49967 PyObject *resultobj = 0;
49968 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49969 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49970 void *argp1 = 0 ;
49971 int res1 = 0 ;
49972 void *argp2 = 0 ;
49973 int res2 = 0 ;
49974 PyObject * obj0 = 0 ;
49975 PyObject * obj1 = 0 ;
49976 char * kwnames[] = {
49977 (char *) "self",(char *) "sizer", NULL
49978 };
49979
49980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49982 if (!SWIG_IsOK(res1)) {
49983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49984 }
49985 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49987 if (!SWIG_IsOK(res2)) {
49988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49989 }
49990 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49991 {
49992 PyThreadState* __tstate = wxPyBeginAllowThreads();
49993 (arg1)->SetGBSizer(arg2);
49994 wxPyEndAllowThreads(__tstate);
49995 if (PyErr_Occurred()) SWIG_fail;
49996 }
49997 resultobj = SWIG_Py_Void();
49998 return resultobj;
49999 fail:
50000 return NULL;
50001 }
50002
50003
50004 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50005 PyObject *obj;
50006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50007 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50008 return SWIG_Py_Void();
50009 }
50010
50011 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50012 return SWIG_Python_InitShadowInstance(args);
50013 }
50014
50015 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50016 PyObject *resultobj = 0;
50017 int arg1 = (int) 0 ;
50018 int arg2 = (int) 0 ;
50019 wxGridBagSizer *result = 0 ;
50020 int val1 ;
50021 int ecode1 = 0 ;
50022 int val2 ;
50023 int ecode2 = 0 ;
50024 PyObject * obj0 = 0 ;
50025 PyObject * obj1 = 0 ;
50026 char * kwnames[] = {
50027 (char *) "vgap",(char *) "hgap", NULL
50028 };
50029
50030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50031 if (obj0) {
50032 ecode1 = SWIG_AsVal_int(obj0, &val1);
50033 if (!SWIG_IsOK(ecode1)) {
50034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50035 }
50036 arg1 = static_cast< int >(val1);
50037 }
50038 if (obj1) {
50039 ecode2 = SWIG_AsVal_int(obj1, &val2);
50040 if (!SWIG_IsOK(ecode2)) {
50041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50042 }
50043 arg2 = static_cast< int >(val2);
50044 }
50045 {
50046 PyThreadState* __tstate = wxPyBeginAllowThreads();
50047 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50048 wxPyEndAllowThreads(__tstate);
50049 if (PyErr_Occurred()) SWIG_fail;
50050 }
50051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50052 return resultobj;
50053 fail:
50054 return NULL;
50055 }
50056
50057
50058 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50059 PyObject *resultobj = 0;
50060 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50061 PyObject *arg2 = (PyObject *) 0 ;
50062 wxGBPosition *arg3 = 0 ;
50063 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50064 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50065 int arg5 = (int) 0 ;
50066 int arg6 = (int) 0 ;
50067 PyObject *arg7 = (PyObject *) NULL ;
50068 wxGBSizerItem *result = 0 ;
50069 void *argp1 = 0 ;
50070 int res1 = 0 ;
50071 wxGBPosition temp3 ;
50072 wxGBSpan temp4 ;
50073 int val5 ;
50074 int ecode5 = 0 ;
50075 int val6 ;
50076 int ecode6 = 0 ;
50077 PyObject * obj0 = 0 ;
50078 PyObject * obj1 = 0 ;
50079 PyObject * obj2 = 0 ;
50080 PyObject * obj3 = 0 ;
50081 PyObject * obj4 = 0 ;
50082 PyObject * obj5 = 0 ;
50083 PyObject * obj6 = 0 ;
50084 char * kwnames[] = {
50085 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50086 };
50087
50088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50090 if (!SWIG_IsOK(res1)) {
50091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50092 }
50093 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50094 arg2 = obj1;
50095 {
50096 arg3 = &temp3;
50097 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50098 }
50099 if (obj3) {
50100 {
50101 arg4 = &temp4;
50102 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50103 }
50104 }
50105 if (obj4) {
50106 ecode5 = SWIG_AsVal_int(obj4, &val5);
50107 if (!SWIG_IsOK(ecode5)) {
50108 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50109 }
50110 arg5 = static_cast< int >(val5);
50111 }
50112 if (obj5) {
50113 ecode6 = SWIG_AsVal_int(obj5, &val6);
50114 if (!SWIG_IsOK(ecode6)) {
50115 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50116 }
50117 arg6 = static_cast< int >(val6);
50118 }
50119 if (obj6) {
50120 arg7 = obj6;
50121 }
50122 {
50123 PyThreadState* __tstate = wxPyBeginAllowThreads();
50124 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50125 wxPyEndAllowThreads(__tstate);
50126 if (PyErr_Occurred()) SWIG_fail;
50127 }
50128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50129 return resultobj;
50130 fail:
50131 return NULL;
50132 }
50133
50134
50135 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50136 PyObject *resultobj = 0;
50137 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50138 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50139 wxGBSizerItem *result = 0 ;
50140 void *argp1 = 0 ;
50141 int res1 = 0 ;
50142 int res2 = 0 ;
50143 PyObject * obj0 = 0 ;
50144 PyObject * obj1 = 0 ;
50145 char * kwnames[] = {
50146 (char *) "self",(char *) "item", NULL
50147 };
50148
50149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50151 if (!SWIG_IsOK(res1)) {
50152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50153 }
50154 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50155 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50156 if (!SWIG_IsOK(res2)) {
50157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50158 }
50159 {
50160 PyThreadState* __tstate = wxPyBeginAllowThreads();
50161 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50162 wxPyEndAllowThreads(__tstate);
50163 if (PyErr_Occurred()) SWIG_fail;
50164 }
50165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50166 return resultobj;
50167 fail:
50168 return NULL;
50169 }
50170
50171
50172 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50173 PyObject *resultobj = 0;
50174 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50175 int arg2 ;
50176 int arg3 ;
50177 wxSize result;
50178 void *argp1 = 0 ;
50179 int res1 = 0 ;
50180 int val2 ;
50181 int ecode2 = 0 ;
50182 int val3 ;
50183 int ecode3 = 0 ;
50184 PyObject * obj0 = 0 ;
50185 PyObject * obj1 = 0 ;
50186 PyObject * obj2 = 0 ;
50187 char * kwnames[] = {
50188 (char *) "self",(char *) "row",(char *) "col", NULL
50189 };
50190
50191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50193 if (!SWIG_IsOK(res1)) {
50194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50195 }
50196 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50197 ecode2 = SWIG_AsVal_int(obj1, &val2);
50198 if (!SWIG_IsOK(ecode2)) {
50199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50200 }
50201 arg2 = static_cast< int >(val2);
50202 ecode3 = SWIG_AsVal_int(obj2, &val3);
50203 if (!SWIG_IsOK(ecode3)) {
50204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50205 }
50206 arg3 = static_cast< int >(val3);
50207 {
50208 PyThreadState* __tstate = wxPyBeginAllowThreads();
50209 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50210 wxPyEndAllowThreads(__tstate);
50211 if (PyErr_Occurred()) SWIG_fail;
50212 }
50213 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50214 return resultobj;
50215 fail:
50216 return NULL;
50217 }
50218
50219
50220 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50221 PyObject *resultobj = 0;
50222 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50223 wxSize result;
50224 void *argp1 = 0 ;
50225 int res1 = 0 ;
50226 PyObject *swig_obj[1] ;
50227
50228 if (!args) SWIG_fail;
50229 swig_obj[0] = args;
50230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50231 if (!SWIG_IsOK(res1)) {
50232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50233 }
50234 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50235 {
50236 PyThreadState* __tstate = wxPyBeginAllowThreads();
50237 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50238 wxPyEndAllowThreads(__tstate);
50239 if (PyErr_Occurred()) SWIG_fail;
50240 }
50241 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50242 return resultobj;
50243 fail:
50244 return NULL;
50245 }
50246
50247
50248 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50249 PyObject *resultobj = 0;
50250 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50251 wxSize *arg2 = 0 ;
50252 void *argp1 = 0 ;
50253 int res1 = 0 ;
50254 wxSize temp2 ;
50255 PyObject * obj0 = 0 ;
50256 PyObject * obj1 = 0 ;
50257 char * kwnames[] = {
50258 (char *) "self",(char *) "sz", NULL
50259 };
50260
50261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50263 if (!SWIG_IsOK(res1)) {
50264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50265 }
50266 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50267 {
50268 arg2 = &temp2;
50269 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50270 }
50271 {
50272 PyThreadState* __tstate = wxPyBeginAllowThreads();
50273 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50274 wxPyEndAllowThreads(__tstate);
50275 if (PyErr_Occurred()) SWIG_fail;
50276 }
50277 resultobj = SWIG_Py_Void();
50278 return resultobj;
50279 fail:
50280 return NULL;
50281 }
50282
50283
50284 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50285 PyObject *resultobj = 0;
50286 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50287 wxWindow *arg2 = (wxWindow *) 0 ;
50288 wxGBPosition result;
50289 void *argp1 = 0 ;
50290 int res1 = 0 ;
50291 void *argp2 = 0 ;
50292 int res2 = 0 ;
50293
50294 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50296 if (!SWIG_IsOK(res1)) {
50297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50298 }
50299 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50300 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50301 if (!SWIG_IsOK(res2)) {
50302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50303 }
50304 arg2 = reinterpret_cast< wxWindow * >(argp2);
50305 {
50306 PyThreadState* __tstate = wxPyBeginAllowThreads();
50307 result = (arg1)->GetItemPosition(arg2);
50308 wxPyEndAllowThreads(__tstate);
50309 if (PyErr_Occurred()) SWIG_fail;
50310 }
50311 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50312 return resultobj;
50313 fail:
50314 return NULL;
50315 }
50316
50317
50318 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50319 PyObject *resultobj = 0;
50320 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50321 wxSizer *arg2 = (wxSizer *) 0 ;
50322 wxGBPosition result;
50323 void *argp1 = 0 ;
50324 int res1 = 0 ;
50325 void *argp2 = 0 ;
50326 int res2 = 0 ;
50327
50328 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50330 if (!SWIG_IsOK(res1)) {
50331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50332 }
50333 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50334 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50335 if (!SWIG_IsOK(res2)) {
50336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50337 }
50338 arg2 = reinterpret_cast< wxSizer * >(argp2);
50339 {
50340 PyThreadState* __tstate = wxPyBeginAllowThreads();
50341 result = (arg1)->GetItemPosition(arg2);
50342 wxPyEndAllowThreads(__tstate);
50343 if (PyErr_Occurred()) SWIG_fail;
50344 }
50345 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50346 return resultobj;
50347 fail:
50348 return NULL;
50349 }
50350
50351
50352 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50353 PyObject *resultobj = 0;
50354 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50355 size_t arg2 ;
50356 wxGBPosition result;
50357 void *argp1 = 0 ;
50358 int res1 = 0 ;
50359 size_t val2 ;
50360 int ecode2 = 0 ;
50361
50362 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50364 if (!SWIG_IsOK(res1)) {
50365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50366 }
50367 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50368 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50369 if (!SWIG_IsOK(ecode2)) {
50370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50371 }
50372 arg2 = static_cast< size_t >(val2);
50373 {
50374 PyThreadState* __tstate = wxPyBeginAllowThreads();
50375 result = (arg1)->GetItemPosition(arg2);
50376 wxPyEndAllowThreads(__tstate);
50377 if (PyErr_Occurred()) SWIG_fail;
50378 }
50379 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50380 return resultobj;
50381 fail:
50382 return NULL;
50383 }
50384
50385
50386 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50387 int argc;
50388 PyObject *argv[3];
50389
50390 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50391 --argc;
50392 if (argc == 2) {
50393 int _v = 0;
50394 {
50395 void *vptr = 0;
50396 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50397 _v = SWIG_CheckState(res);
50398 }
50399 if (!_v) goto check_1;
50400 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50401 }
50402 check_1:
50403
50404 if (argc == 2) {
50405 int _v = 0;
50406 {
50407 void *vptr = 0;
50408 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50409 _v = SWIG_CheckState(res);
50410 }
50411 if (!_v) goto check_2;
50412 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50413 }
50414 check_2:
50415
50416 if (argc == 2) {
50417 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50418 }
50419
50420 fail:
50421 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50422 return NULL;
50423 }
50424
50425
50426 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50427 PyObject *resultobj = 0;
50428 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50429 wxWindow *arg2 = (wxWindow *) 0 ;
50430 wxGBPosition *arg3 = 0 ;
50431 bool result;
50432 void *argp1 = 0 ;
50433 int res1 = 0 ;
50434 void *argp2 = 0 ;
50435 int res2 = 0 ;
50436 wxGBPosition temp3 ;
50437
50438 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50440 if (!SWIG_IsOK(res1)) {
50441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50442 }
50443 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50444 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50445 if (!SWIG_IsOK(res2)) {
50446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50447 }
50448 arg2 = reinterpret_cast< wxWindow * >(argp2);
50449 {
50450 arg3 = &temp3;
50451 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50452 }
50453 {
50454 PyThreadState* __tstate = wxPyBeginAllowThreads();
50455 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50456 wxPyEndAllowThreads(__tstate);
50457 if (PyErr_Occurred()) SWIG_fail;
50458 }
50459 {
50460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50461 }
50462 return resultobj;
50463 fail:
50464 return NULL;
50465 }
50466
50467
50468 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50469 PyObject *resultobj = 0;
50470 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50471 wxSizer *arg2 = (wxSizer *) 0 ;
50472 wxGBPosition *arg3 = 0 ;
50473 bool result;
50474 void *argp1 = 0 ;
50475 int res1 = 0 ;
50476 void *argp2 = 0 ;
50477 int res2 = 0 ;
50478 wxGBPosition temp3 ;
50479
50480 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50482 if (!SWIG_IsOK(res1)) {
50483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50484 }
50485 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50486 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50487 if (!SWIG_IsOK(res2)) {
50488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50489 }
50490 arg2 = reinterpret_cast< wxSizer * >(argp2);
50491 {
50492 arg3 = &temp3;
50493 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50494 }
50495 {
50496 PyThreadState* __tstate = wxPyBeginAllowThreads();
50497 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50498 wxPyEndAllowThreads(__tstate);
50499 if (PyErr_Occurred()) SWIG_fail;
50500 }
50501 {
50502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50503 }
50504 return resultobj;
50505 fail:
50506 return NULL;
50507 }
50508
50509
50510 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50511 PyObject *resultobj = 0;
50512 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50513 size_t arg2 ;
50514 wxGBPosition *arg3 = 0 ;
50515 bool result;
50516 void *argp1 = 0 ;
50517 int res1 = 0 ;
50518 size_t val2 ;
50519 int ecode2 = 0 ;
50520 wxGBPosition temp3 ;
50521
50522 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50524 if (!SWIG_IsOK(res1)) {
50525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50526 }
50527 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50528 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50529 if (!SWIG_IsOK(ecode2)) {
50530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50531 }
50532 arg2 = static_cast< size_t >(val2);
50533 {
50534 arg3 = &temp3;
50535 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50536 }
50537 {
50538 PyThreadState* __tstate = wxPyBeginAllowThreads();
50539 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50540 wxPyEndAllowThreads(__tstate);
50541 if (PyErr_Occurred()) SWIG_fail;
50542 }
50543 {
50544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50545 }
50546 return resultobj;
50547 fail:
50548 return NULL;
50549 }
50550
50551
50552 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50553 int argc;
50554 PyObject *argv[4];
50555
50556 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50557 --argc;
50558 if (argc == 3) {
50559 int _v = 0;
50560 {
50561 void *vptr = 0;
50562 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50563 _v = SWIG_CheckState(res);
50564 }
50565 if (!_v) goto check_1;
50566 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50567 }
50568 check_1:
50569
50570 if (argc == 3) {
50571 int _v = 0;
50572 {
50573 void *vptr = 0;
50574 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50575 _v = SWIG_CheckState(res);
50576 }
50577 if (!_v) goto check_2;
50578 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50579 }
50580 check_2:
50581
50582 if (argc == 3) {
50583 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50584 }
50585
50586 fail:
50587 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50588 return NULL;
50589 }
50590
50591
50592 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50593 PyObject *resultobj = 0;
50594 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50595 wxWindow *arg2 = (wxWindow *) 0 ;
50596 wxGBSpan result;
50597 void *argp1 = 0 ;
50598 int res1 = 0 ;
50599 void *argp2 = 0 ;
50600 int res2 = 0 ;
50601
50602 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50604 if (!SWIG_IsOK(res1)) {
50605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50606 }
50607 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50608 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50609 if (!SWIG_IsOK(res2)) {
50610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50611 }
50612 arg2 = reinterpret_cast< wxWindow * >(argp2);
50613 {
50614 PyThreadState* __tstate = wxPyBeginAllowThreads();
50615 result = (arg1)->GetItemSpan(arg2);
50616 wxPyEndAllowThreads(__tstate);
50617 if (PyErr_Occurred()) SWIG_fail;
50618 }
50619 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50620 return resultobj;
50621 fail:
50622 return NULL;
50623 }
50624
50625
50626 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50627 PyObject *resultobj = 0;
50628 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50629 wxSizer *arg2 = (wxSizer *) 0 ;
50630 wxGBSpan result;
50631 void *argp1 = 0 ;
50632 int res1 = 0 ;
50633 void *argp2 = 0 ;
50634 int res2 = 0 ;
50635
50636 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50638 if (!SWIG_IsOK(res1)) {
50639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50640 }
50641 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50642 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50643 if (!SWIG_IsOK(res2)) {
50644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50645 }
50646 arg2 = reinterpret_cast< wxSizer * >(argp2);
50647 {
50648 PyThreadState* __tstate = wxPyBeginAllowThreads();
50649 result = (arg1)->GetItemSpan(arg2);
50650 wxPyEndAllowThreads(__tstate);
50651 if (PyErr_Occurred()) SWIG_fail;
50652 }
50653 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50654 return resultobj;
50655 fail:
50656 return NULL;
50657 }
50658
50659
50660 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50661 PyObject *resultobj = 0;
50662 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50663 size_t arg2 ;
50664 wxGBSpan result;
50665 void *argp1 = 0 ;
50666 int res1 = 0 ;
50667 size_t val2 ;
50668 int ecode2 = 0 ;
50669
50670 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50672 if (!SWIG_IsOK(res1)) {
50673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50674 }
50675 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50676 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50677 if (!SWIG_IsOK(ecode2)) {
50678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50679 }
50680 arg2 = static_cast< size_t >(val2);
50681 {
50682 PyThreadState* __tstate = wxPyBeginAllowThreads();
50683 result = (arg1)->GetItemSpan(arg2);
50684 wxPyEndAllowThreads(__tstate);
50685 if (PyErr_Occurred()) SWIG_fail;
50686 }
50687 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50688 return resultobj;
50689 fail:
50690 return NULL;
50691 }
50692
50693
50694 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50695 int argc;
50696 PyObject *argv[3];
50697
50698 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50699 --argc;
50700 if (argc == 2) {
50701 int _v = 0;
50702 {
50703 void *vptr = 0;
50704 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50705 _v = SWIG_CheckState(res);
50706 }
50707 if (!_v) goto check_1;
50708 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50709 }
50710 check_1:
50711
50712 if (argc == 2) {
50713 int _v = 0;
50714 {
50715 void *vptr = 0;
50716 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50717 _v = SWIG_CheckState(res);
50718 }
50719 if (!_v) goto check_2;
50720 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50721 }
50722 check_2:
50723
50724 if (argc == 2) {
50725 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50726 }
50727
50728 fail:
50729 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50730 return NULL;
50731 }
50732
50733
50734 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50735 PyObject *resultobj = 0;
50736 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50737 wxWindow *arg2 = (wxWindow *) 0 ;
50738 wxGBSpan *arg3 = 0 ;
50739 bool result;
50740 void *argp1 = 0 ;
50741 int res1 = 0 ;
50742 void *argp2 = 0 ;
50743 int res2 = 0 ;
50744 wxGBSpan temp3 ;
50745
50746 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50748 if (!SWIG_IsOK(res1)) {
50749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50750 }
50751 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50752 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50753 if (!SWIG_IsOK(res2)) {
50754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50755 }
50756 arg2 = reinterpret_cast< wxWindow * >(argp2);
50757 {
50758 arg3 = &temp3;
50759 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50760 }
50761 {
50762 PyThreadState* __tstate = wxPyBeginAllowThreads();
50763 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50764 wxPyEndAllowThreads(__tstate);
50765 if (PyErr_Occurred()) SWIG_fail;
50766 }
50767 {
50768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50769 }
50770 return resultobj;
50771 fail:
50772 return NULL;
50773 }
50774
50775
50776 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50777 PyObject *resultobj = 0;
50778 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50779 wxSizer *arg2 = (wxSizer *) 0 ;
50780 wxGBSpan *arg3 = 0 ;
50781 bool result;
50782 void *argp1 = 0 ;
50783 int res1 = 0 ;
50784 void *argp2 = 0 ;
50785 int res2 = 0 ;
50786 wxGBSpan temp3 ;
50787
50788 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50790 if (!SWIG_IsOK(res1)) {
50791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50792 }
50793 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50794 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50795 if (!SWIG_IsOK(res2)) {
50796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50797 }
50798 arg2 = reinterpret_cast< wxSizer * >(argp2);
50799 {
50800 arg3 = &temp3;
50801 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50802 }
50803 {
50804 PyThreadState* __tstate = wxPyBeginAllowThreads();
50805 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50806 wxPyEndAllowThreads(__tstate);
50807 if (PyErr_Occurred()) SWIG_fail;
50808 }
50809 {
50810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50811 }
50812 return resultobj;
50813 fail:
50814 return NULL;
50815 }
50816
50817
50818 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50819 PyObject *resultobj = 0;
50820 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50821 size_t arg2 ;
50822 wxGBSpan *arg3 = 0 ;
50823 bool result;
50824 void *argp1 = 0 ;
50825 int res1 = 0 ;
50826 size_t val2 ;
50827 int ecode2 = 0 ;
50828 wxGBSpan temp3 ;
50829
50830 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50832 if (!SWIG_IsOK(res1)) {
50833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50834 }
50835 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50836 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50837 if (!SWIG_IsOK(ecode2)) {
50838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50839 }
50840 arg2 = static_cast< size_t >(val2);
50841 {
50842 arg3 = &temp3;
50843 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50844 }
50845 {
50846 PyThreadState* __tstate = wxPyBeginAllowThreads();
50847 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50848 wxPyEndAllowThreads(__tstate);
50849 if (PyErr_Occurred()) SWIG_fail;
50850 }
50851 {
50852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50853 }
50854 return resultobj;
50855 fail:
50856 return NULL;
50857 }
50858
50859
50860 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50861 int argc;
50862 PyObject *argv[4];
50863
50864 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50865 --argc;
50866 if (argc == 3) {
50867 int _v = 0;
50868 {
50869 void *vptr = 0;
50870 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50871 _v = SWIG_CheckState(res);
50872 }
50873 if (!_v) goto check_1;
50874 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50875 }
50876 check_1:
50877
50878 if (argc == 3) {
50879 int _v = 0;
50880 {
50881 void *vptr = 0;
50882 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50883 _v = SWIG_CheckState(res);
50884 }
50885 if (!_v) goto check_2;
50886 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50887 }
50888 check_2:
50889
50890 if (argc == 3) {
50891 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50892 }
50893
50894 fail:
50895 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50896 return NULL;
50897 }
50898
50899
50900 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50901 PyObject *resultobj = 0;
50902 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50903 wxWindow *arg2 = (wxWindow *) 0 ;
50904 wxGBSizerItem *result = 0 ;
50905 void *argp1 = 0 ;
50906 int res1 = 0 ;
50907 void *argp2 = 0 ;
50908 int res2 = 0 ;
50909
50910 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50912 if (!SWIG_IsOK(res1)) {
50913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50914 }
50915 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50916 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50917 if (!SWIG_IsOK(res2)) {
50918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50919 }
50920 arg2 = reinterpret_cast< wxWindow * >(argp2);
50921 {
50922 PyThreadState* __tstate = wxPyBeginAllowThreads();
50923 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50924 wxPyEndAllowThreads(__tstate);
50925 if (PyErr_Occurred()) SWIG_fail;
50926 }
50927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50928 return resultobj;
50929 fail:
50930 return NULL;
50931 }
50932
50933
50934 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50935 PyObject *resultobj = 0;
50936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50937 wxSizer *arg2 = (wxSizer *) 0 ;
50938 wxGBSizerItem *result = 0 ;
50939 void *argp1 = 0 ;
50940 int res1 = 0 ;
50941 void *argp2 = 0 ;
50942 int res2 = 0 ;
50943
50944 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50946 if (!SWIG_IsOK(res1)) {
50947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50948 }
50949 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50950 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50951 if (!SWIG_IsOK(res2)) {
50952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50953 }
50954 arg2 = reinterpret_cast< wxSizer * >(argp2);
50955 {
50956 PyThreadState* __tstate = wxPyBeginAllowThreads();
50957 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50958 wxPyEndAllowThreads(__tstate);
50959 if (PyErr_Occurred()) SWIG_fail;
50960 }
50961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50962 return resultobj;
50963 fail:
50964 return NULL;
50965 }
50966
50967
50968 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50969 int argc;
50970 PyObject *argv[3];
50971
50972 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50973 --argc;
50974 if (argc == 2) {
50975 int _v = 0;
50976 {
50977 void *vptr = 0;
50978 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50979 _v = SWIG_CheckState(res);
50980 }
50981 if (!_v) goto check_1;
50982 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50983 }
50984 check_1:
50985
50986 if (argc == 2) {
50987 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50988 }
50989
50990 fail:
50991 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50992 return NULL;
50993 }
50994
50995
50996 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50997 PyObject *resultobj = 0;
50998 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50999 wxGBPosition *arg2 = 0 ;
51000 wxGBSizerItem *result = 0 ;
51001 void *argp1 = 0 ;
51002 int res1 = 0 ;
51003 wxGBPosition temp2 ;
51004 PyObject * obj0 = 0 ;
51005 PyObject * obj1 = 0 ;
51006 char * kwnames[] = {
51007 (char *) "self",(char *) "pos", NULL
51008 };
51009
51010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51012 if (!SWIG_IsOK(res1)) {
51013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51014 }
51015 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51016 {
51017 arg2 = &temp2;
51018 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51019 }
51020 {
51021 PyThreadState* __tstate = wxPyBeginAllowThreads();
51022 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51023 wxPyEndAllowThreads(__tstate);
51024 if (PyErr_Occurred()) SWIG_fail;
51025 }
51026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51027 return resultobj;
51028 fail:
51029 return NULL;
51030 }
51031
51032
51033 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51034 PyObject *resultobj = 0;
51035 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51036 wxPoint *arg2 = 0 ;
51037 wxGBSizerItem *result = 0 ;
51038 void *argp1 = 0 ;
51039 int res1 = 0 ;
51040 wxPoint temp2 ;
51041 PyObject * obj0 = 0 ;
51042 PyObject * obj1 = 0 ;
51043 char * kwnames[] = {
51044 (char *) "self",(char *) "pt", NULL
51045 };
51046
51047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51049 if (!SWIG_IsOK(res1)) {
51050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51051 }
51052 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51053 {
51054 arg2 = &temp2;
51055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51056 }
51057 {
51058 PyThreadState* __tstate = wxPyBeginAllowThreads();
51059 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51060 wxPyEndAllowThreads(__tstate);
51061 if (PyErr_Occurred()) SWIG_fail;
51062 }
51063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51064 return resultobj;
51065 fail:
51066 return NULL;
51067 }
51068
51069
51070 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51071 PyObject *resultobj = 0;
51072 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51073 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51074 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51075 bool result;
51076 void *argp1 = 0 ;
51077 int res1 = 0 ;
51078 void *argp2 = 0 ;
51079 int res2 = 0 ;
51080 void *argp3 = 0 ;
51081 int res3 = 0 ;
51082 PyObject * obj0 = 0 ;
51083 PyObject * obj1 = 0 ;
51084 PyObject * obj2 = 0 ;
51085 char * kwnames[] = {
51086 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51087 };
51088
51089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51091 if (!SWIG_IsOK(res1)) {
51092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51093 }
51094 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51095 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51096 if (!SWIG_IsOK(res2)) {
51097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51098 }
51099 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51100 if (obj2) {
51101 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51102 if (!SWIG_IsOK(res3)) {
51103 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51104 }
51105 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51106 }
51107 {
51108 PyThreadState* __tstate = wxPyBeginAllowThreads();
51109 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51110 wxPyEndAllowThreads(__tstate);
51111 if (PyErr_Occurred()) SWIG_fail;
51112 }
51113 {
51114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51115 }
51116 return resultobj;
51117 fail:
51118 return NULL;
51119 }
51120
51121
51122 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51123 PyObject *resultobj = 0;
51124 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51125 wxGBPosition *arg2 = 0 ;
51126 wxGBSpan *arg3 = 0 ;
51127 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51128 bool result;
51129 void *argp1 = 0 ;
51130 int res1 = 0 ;
51131 wxGBPosition temp2 ;
51132 wxGBSpan temp3 ;
51133 void *argp4 = 0 ;
51134 int res4 = 0 ;
51135 PyObject * obj0 = 0 ;
51136 PyObject * obj1 = 0 ;
51137 PyObject * obj2 = 0 ;
51138 PyObject * obj3 = 0 ;
51139 char * kwnames[] = {
51140 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51141 };
51142
51143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51145 if (!SWIG_IsOK(res1)) {
51146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51147 }
51148 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51149 {
51150 arg2 = &temp2;
51151 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51152 }
51153 {
51154 arg3 = &temp3;
51155 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51156 }
51157 if (obj3) {
51158 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51159 if (!SWIG_IsOK(res4)) {
51160 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51161 }
51162 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51163 }
51164 {
51165 PyThreadState* __tstate = wxPyBeginAllowThreads();
51166 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51167 wxPyEndAllowThreads(__tstate);
51168 if (PyErr_Occurred()) SWIG_fail;
51169 }
51170 {
51171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51172 }
51173 return resultobj;
51174 fail:
51175 return NULL;
51176 }
51177
51178
51179 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51180 PyObject *obj;
51181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51182 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51183 return SWIG_Py_Void();
51184 }
51185
51186 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51187 return SWIG_Python_InitShadowInstance(args);
51188 }
51189
51190 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51191 PyObject *resultobj = 0;
51192 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51193 wxRelationship arg2 ;
51194 wxWindow *arg3 = (wxWindow *) 0 ;
51195 wxEdge arg4 ;
51196 int arg5 = (int) 0 ;
51197 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51198 void *argp1 = 0 ;
51199 int res1 = 0 ;
51200 int val2 ;
51201 int ecode2 = 0 ;
51202 void *argp3 = 0 ;
51203 int res3 = 0 ;
51204 int val4 ;
51205 int ecode4 = 0 ;
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 char * kwnames[] = {
51217 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51218 };
51219
51220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51222 if (!SWIG_IsOK(res1)) {
51223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51224 }
51225 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51226 ecode2 = SWIG_AsVal_int(obj1, &val2);
51227 if (!SWIG_IsOK(ecode2)) {
51228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51229 }
51230 arg2 = static_cast< wxRelationship >(val2);
51231 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51232 if (!SWIG_IsOK(res3)) {
51233 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51234 }
51235 arg3 = reinterpret_cast< wxWindow * >(argp3);
51236 ecode4 = SWIG_AsVal_int(obj3, &val4);
51237 if (!SWIG_IsOK(ecode4)) {
51238 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51239 }
51240 arg4 = static_cast< wxEdge >(val4);
51241 if (obj4) {
51242 ecode5 = SWIG_AsVal_int(obj4, &val5);
51243 if (!SWIG_IsOK(ecode5)) {
51244 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51245 }
51246 arg5 = static_cast< int >(val5);
51247 }
51248 if (obj5) {
51249 ecode6 = SWIG_AsVal_int(obj5, &val6);
51250 if (!SWIG_IsOK(ecode6)) {
51251 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51252 }
51253 arg6 = static_cast< int >(val6);
51254 }
51255 {
51256 PyThreadState* __tstate = wxPyBeginAllowThreads();
51257 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51258 wxPyEndAllowThreads(__tstate);
51259 if (PyErr_Occurred()) SWIG_fail;
51260 }
51261 resultobj = SWIG_Py_Void();
51262 return resultobj;
51263 fail:
51264 return NULL;
51265 }
51266
51267
51268 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51269 PyObject *resultobj = 0;
51270 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51271 wxWindow *arg2 = (wxWindow *) 0 ;
51272 int arg3 = (int) 0 ;
51273 void *argp1 = 0 ;
51274 int res1 = 0 ;
51275 void *argp2 = 0 ;
51276 int res2 = 0 ;
51277 int val3 ;
51278 int ecode3 = 0 ;
51279 PyObject * obj0 = 0 ;
51280 PyObject * obj1 = 0 ;
51281 PyObject * obj2 = 0 ;
51282 char * kwnames[] = {
51283 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51284 };
51285
51286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51288 if (!SWIG_IsOK(res1)) {
51289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51290 }
51291 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51292 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51293 if (!SWIG_IsOK(res2)) {
51294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51295 }
51296 arg2 = reinterpret_cast< wxWindow * >(argp2);
51297 if (obj2) {
51298 ecode3 = SWIG_AsVal_int(obj2, &val3);
51299 if (!SWIG_IsOK(ecode3)) {
51300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51301 }
51302 arg3 = static_cast< int >(val3);
51303 }
51304 {
51305 PyThreadState* __tstate = wxPyBeginAllowThreads();
51306 (arg1)->LeftOf(arg2,arg3);
51307 wxPyEndAllowThreads(__tstate);
51308 if (PyErr_Occurred()) SWIG_fail;
51309 }
51310 resultobj = SWIG_Py_Void();
51311 return resultobj;
51312 fail:
51313 return NULL;
51314 }
51315
51316
51317 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51318 PyObject *resultobj = 0;
51319 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51320 wxWindow *arg2 = (wxWindow *) 0 ;
51321 int arg3 = (int) 0 ;
51322 void *argp1 = 0 ;
51323 int res1 = 0 ;
51324 void *argp2 = 0 ;
51325 int res2 = 0 ;
51326 int val3 ;
51327 int ecode3 = 0 ;
51328 PyObject * obj0 = 0 ;
51329 PyObject * obj1 = 0 ;
51330 PyObject * obj2 = 0 ;
51331 char * kwnames[] = {
51332 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51333 };
51334
51335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51337 if (!SWIG_IsOK(res1)) {
51338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51339 }
51340 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51341 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51342 if (!SWIG_IsOK(res2)) {
51343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51344 }
51345 arg2 = reinterpret_cast< wxWindow * >(argp2);
51346 if (obj2) {
51347 ecode3 = SWIG_AsVal_int(obj2, &val3);
51348 if (!SWIG_IsOK(ecode3)) {
51349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51350 }
51351 arg3 = static_cast< int >(val3);
51352 }
51353 {
51354 PyThreadState* __tstate = wxPyBeginAllowThreads();
51355 (arg1)->RightOf(arg2,arg3);
51356 wxPyEndAllowThreads(__tstate);
51357 if (PyErr_Occurred()) SWIG_fail;
51358 }
51359 resultobj = SWIG_Py_Void();
51360 return resultobj;
51361 fail:
51362 return NULL;
51363 }
51364
51365
51366 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51367 PyObject *resultobj = 0;
51368 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51369 wxWindow *arg2 = (wxWindow *) 0 ;
51370 int arg3 = (int) 0 ;
51371 void *argp1 = 0 ;
51372 int res1 = 0 ;
51373 void *argp2 = 0 ;
51374 int res2 = 0 ;
51375 int val3 ;
51376 int ecode3 = 0 ;
51377 PyObject * obj0 = 0 ;
51378 PyObject * obj1 = 0 ;
51379 PyObject * obj2 = 0 ;
51380 char * kwnames[] = {
51381 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51382 };
51383
51384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51386 if (!SWIG_IsOK(res1)) {
51387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51388 }
51389 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51390 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51391 if (!SWIG_IsOK(res2)) {
51392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51393 }
51394 arg2 = reinterpret_cast< wxWindow * >(argp2);
51395 if (obj2) {
51396 ecode3 = SWIG_AsVal_int(obj2, &val3);
51397 if (!SWIG_IsOK(ecode3)) {
51398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51399 }
51400 arg3 = static_cast< int >(val3);
51401 }
51402 {
51403 PyThreadState* __tstate = wxPyBeginAllowThreads();
51404 (arg1)->Above(arg2,arg3);
51405 wxPyEndAllowThreads(__tstate);
51406 if (PyErr_Occurred()) SWIG_fail;
51407 }
51408 resultobj = SWIG_Py_Void();
51409 return resultobj;
51410 fail:
51411 return NULL;
51412 }
51413
51414
51415 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51416 PyObject *resultobj = 0;
51417 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51418 wxWindow *arg2 = (wxWindow *) 0 ;
51419 int arg3 = (int) 0 ;
51420 void *argp1 = 0 ;
51421 int res1 = 0 ;
51422 void *argp2 = 0 ;
51423 int res2 = 0 ;
51424 int val3 ;
51425 int ecode3 = 0 ;
51426 PyObject * obj0 = 0 ;
51427 PyObject * obj1 = 0 ;
51428 PyObject * obj2 = 0 ;
51429 char * kwnames[] = {
51430 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51431 };
51432
51433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51435 if (!SWIG_IsOK(res1)) {
51436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51437 }
51438 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51439 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51440 if (!SWIG_IsOK(res2)) {
51441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51442 }
51443 arg2 = reinterpret_cast< wxWindow * >(argp2);
51444 if (obj2) {
51445 ecode3 = SWIG_AsVal_int(obj2, &val3);
51446 if (!SWIG_IsOK(ecode3)) {
51447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51448 }
51449 arg3 = static_cast< int >(val3);
51450 }
51451 {
51452 PyThreadState* __tstate = wxPyBeginAllowThreads();
51453 (arg1)->Below(arg2,arg3);
51454 wxPyEndAllowThreads(__tstate);
51455 if (PyErr_Occurred()) SWIG_fail;
51456 }
51457 resultobj = SWIG_Py_Void();
51458 return resultobj;
51459 fail:
51460 return NULL;
51461 }
51462
51463
51464 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51465 PyObject *resultobj = 0;
51466 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51467 wxWindow *arg2 = (wxWindow *) 0 ;
51468 wxEdge arg3 ;
51469 int arg4 = (int) 0 ;
51470 void *argp1 = 0 ;
51471 int res1 = 0 ;
51472 void *argp2 = 0 ;
51473 int res2 = 0 ;
51474 int val3 ;
51475 int ecode3 = 0 ;
51476 int val4 ;
51477 int ecode4 = 0 ;
51478 PyObject * obj0 = 0 ;
51479 PyObject * obj1 = 0 ;
51480 PyObject * obj2 = 0 ;
51481 PyObject * obj3 = 0 ;
51482 char * kwnames[] = {
51483 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51484 };
51485
51486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51488 if (!SWIG_IsOK(res1)) {
51489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51490 }
51491 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51493 if (!SWIG_IsOK(res2)) {
51494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51495 }
51496 arg2 = reinterpret_cast< wxWindow * >(argp2);
51497 ecode3 = SWIG_AsVal_int(obj2, &val3);
51498 if (!SWIG_IsOK(ecode3)) {
51499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51500 }
51501 arg3 = static_cast< wxEdge >(val3);
51502 if (obj3) {
51503 ecode4 = SWIG_AsVal_int(obj3, &val4);
51504 if (!SWIG_IsOK(ecode4)) {
51505 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51506 }
51507 arg4 = static_cast< int >(val4);
51508 }
51509 {
51510 PyThreadState* __tstate = wxPyBeginAllowThreads();
51511 (arg1)->SameAs(arg2,arg3,arg4);
51512 wxPyEndAllowThreads(__tstate);
51513 if (PyErr_Occurred()) SWIG_fail;
51514 }
51515 resultobj = SWIG_Py_Void();
51516 return resultobj;
51517 fail:
51518 return NULL;
51519 }
51520
51521
51522 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51523 PyObject *resultobj = 0;
51524 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51525 wxWindow *arg2 = (wxWindow *) 0 ;
51526 wxEdge arg3 ;
51527 int arg4 ;
51528 void *argp1 = 0 ;
51529 int res1 = 0 ;
51530 void *argp2 = 0 ;
51531 int res2 = 0 ;
51532 int val3 ;
51533 int ecode3 = 0 ;
51534 int val4 ;
51535 int ecode4 = 0 ;
51536 PyObject * obj0 = 0 ;
51537 PyObject * obj1 = 0 ;
51538 PyObject * obj2 = 0 ;
51539 PyObject * obj3 = 0 ;
51540 char * kwnames[] = {
51541 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51542 };
51543
51544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51546 if (!SWIG_IsOK(res1)) {
51547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51548 }
51549 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51550 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51551 if (!SWIG_IsOK(res2)) {
51552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51553 }
51554 arg2 = reinterpret_cast< wxWindow * >(argp2);
51555 ecode3 = SWIG_AsVal_int(obj2, &val3);
51556 if (!SWIG_IsOK(ecode3)) {
51557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51558 }
51559 arg3 = static_cast< wxEdge >(val3);
51560 ecode4 = SWIG_AsVal_int(obj3, &val4);
51561 if (!SWIG_IsOK(ecode4)) {
51562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51563 }
51564 arg4 = static_cast< int >(val4);
51565 {
51566 PyThreadState* __tstate = wxPyBeginAllowThreads();
51567 (arg1)->PercentOf(arg2,arg3,arg4);
51568 wxPyEndAllowThreads(__tstate);
51569 if (PyErr_Occurred()) SWIG_fail;
51570 }
51571 resultobj = SWIG_Py_Void();
51572 return resultobj;
51573 fail:
51574 return NULL;
51575 }
51576
51577
51578 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51579 PyObject *resultobj = 0;
51580 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51581 int arg2 ;
51582 void *argp1 = 0 ;
51583 int res1 = 0 ;
51584 int val2 ;
51585 int ecode2 = 0 ;
51586 PyObject * obj0 = 0 ;
51587 PyObject * obj1 = 0 ;
51588 char * kwnames[] = {
51589 (char *) "self",(char *) "val", NULL
51590 };
51591
51592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51594 if (!SWIG_IsOK(res1)) {
51595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51596 }
51597 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51598 ecode2 = SWIG_AsVal_int(obj1, &val2);
51599 if (!SWIG_IsOK(ecode2)) {
51600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51601 }
51602 arg2 = static_cast< int >(val2);
51603 {
51604 PyThreadState* __tstate = wxPyBeginAllowThreads();
51605 (arg1)->Absolute(arg2);
51606 wxPyEndAllowThreads(__tstate);
51607 if (PyErr_Occurred()) SWIG_fail;
51608 }
51609 resultobj = SWIG_Py_Void();
51610 return resultobj;
51611 fail:
51612 return NULL;
51613 }
51614
51615
51616 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51617 PyObject *resultobj = 0;
51618 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51619 void *argp1 = 0 ;
51620 int res1 = 0 ;
51621 PyObject *swig_obj[1] ;
51622
51623 if (!args) SWIG_fail;
51624 swig_obj[0] = args;
51625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51626 if (!SWIG_IsOK(res1)) {
51627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51628 }
51629 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51630 {
51631 PyThreadState* __tstate = wxPyBeginAllowThreads();
51632 (arg1)->Unconstrained();
51633 wxPyEndAllowThreads(__tstate);
51634 if (PyErr_Occurred()) SWIG_fail;
51635 }
51636 resultobj = SWIG_Py_Void();
51637 return resultobj;
51638 fail:
51639 return NULL;
51640 }
51641
51642
51643 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51644 PyObject *resultobj = 0;
51645 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51646 void *argp1 = 0 ;
51647 int res1 = 0 ;
51648 PyObject *swig_obj[1] ;
51649
51650 if (!args) SWIG_fail;
51651 swig_obj[0] = args;
51652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51653 if (!SWIG_IsOK(res1)) {
51654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51655 }
51656 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51657 {
51658 PyThreadState* __tstate = wxPyBeginAllowThreads();
51659 (arg1)->AsIs();
51660 wxPyEndAllowThreads(__tstate);
51661 if (PyErr_Occurred()) SWIG_fail;
51662 }
51663 resultobj = SWIG_Py_Void();
51664 return resultobj;
51665 fail:
51666 return NULL;
51667 }
51668
51669
51670 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51671 PyObject *resultobj = 0;
51672 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51673 wxWindow *result = 0 ;
51674 void *argp1 = 0 ;
51675 int res1 = 0 ;
51676 PyObject *swig_obj[1] ;
51677
51678 if (!args) SWIG_fail;
51679 swig_obj[0] = args;
51680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51681 if (!SWIG_IsOK(res1)) {
51682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51683 }
51684 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51685 {
51686 PyThreadState* __tstate = wxPyBeginAllowThreads();
51687 result = (wxWindow *)(arg1)->GetOtherWindow();
51688 wxPyEndAllowThreads(__tstate);
51689 if (PyErr_Occurred()) SWIG_fail;
51690 }
51691 {
51692 resultobj = wxPyMake_wxObject(result, 0);
51693 }
51694 return resultobj;
51695 fail:
51696 return NULL;
51697 }
51698
51699
51700 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51701 PyObject *resultobj = 0;
51702 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51703 wxEdge result;
51704 void *argp1 = 0 ;
51705 int res1 = 0 ;
51706 PyObject *swig_obj[1] ;
51707
51708 if (!args) SWIG_fail;
51709 swig_obj[0] = args;
51710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51711 if (!SWIG_IsOK(res1)) {
51712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51713 }
51714 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51715 {
51716 PyThreadState* __tstate = wxPyBeginAllowThreads();
51717 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51718 wxPyEndAllowThreads(__tstate);
51719 if (PyErr_Occurred()) SWIG_fail;
51720 }
51721 resultobj = SWIG_From_int(static_cast< int >(result));
51722 return resultobj;
51723 fail:
51724 return NULL;
51725 }
51726
51727
51728 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51729 PyObject *resultobj = 0;
51730 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51731 wxEdge arg2 ;
51732 void *argp1 = 0 ;
51733 int res1 = 0 ;
51734 int val2 ;
51735 int ecode2 = 0 ;
51736 PyObject * obj0 = 0 ;
51737 PyObject * obj1 = 0 ;
51738 char * kwnames[] = {
51739 (char *) "self",(char *) "which", NULL
51740 };
51741
51742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51744 if (!SWIG_IsOK(res1)) {
51745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51746 }
51747 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51748 ecode2 = SWIG_AsVal_int(obj1, &val2);
51749 if (!SWIG_IsOK(ecode2)) {
51750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51751 }
51752 arg2 = static_cast< wxEdge >(val2);
51753 {
51754 PyThreadState* __tstate = wxPyBeginAllowThreads();
51755 (arg1)->SetEdge(arg2);
51756 wxPyEndAllowThreads(__tstate);
51757 if (PyErr_Occurred()) SWIG_fail;
51758 }
51759 resultobj = SWIG_Py_Void();
51760 return resultobj;
51761 fail:
51762 return NULL;
51763 }
51764
51765
51766 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51767 PyObject *resultobj = 0;
51768 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51769 int arg2 ;
51770 void *argp1 = 0 ;
51771 int res1 = 0 ;
51772 int val2 ;
51773 int ecode2 = 0 ;
51774 PyObject * obj0 = 0 ;
51775 PyObject * obj1 = 0 ;
51776 char * kwnames[] = {
51777 (char *) "self",(char *) "v", NULL
51778 };
51779
51780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51782 if (!SWIG_IsOK(res1)) {
51783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51784 }
51785 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51786 ecode2 = SWIG_AsVal_int(obj1, &val2);
51787 if (!SWIG_IsOK(ecode2)) {
51788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51789 }
51790 arg2 = static_cast< int >(val2);
51791 {
51792 PyThreadState* __tstate = wxPyBeginAllowThreads();
51793 (arg1)->SetValue(arg2);
51794 wxPyEndAllowThreads(__tstate);
51795 if (PyErr_Occurred()) SWIG_fail;
51796 }
51797 resultobj = SWIG_Py_Void();
51798 return resultobj;
51799 fail:
51800 return NULL;
51801 }
51802
51803
51804 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51805 PyObject *resultobj = 0;
51806 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51807 int result;
51808 void *argp1 = 0 ;
51809 int res1 = 0 ;
51810 PyObject *swig_obj[1] ;
51811
51812 if (!args) SWIG_fail;
51813 swig_obj[0] = args;
51814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51815 if (!SWIG_IsOK(res1)) {
51816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51817 }
51818 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51819 {
51820 PyThreadState* __tstate = wxPyBeginAllowThreads();
51821 result = (int)(arg1)->GetMargin();
51822 wxPyEndAllowThreads(__tstate);
51823 if (PyErr_Occurred()) SWIG_fail;
51824 }
51825 resultobj = SWIG_From_int(static_cast< int >(result));
51826 return resultobj;
51827 fail:
51828 return NULL;
51829 }
51830
51831
51832 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51833 PyObject *resultobj = 0;
51834 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51835 int arg2 ;
51836 void *argp1 = 0 ;
51837 int res1 = 0 ;
51838 int val2 ;
51839 int ecode2 = 0 ;
51840 PyObject * obj0 = 0 ;
51841 PyObject * obj1 = 0 ;
51842 char * kwnames[] = {
51843 (char *) "self",(char *) "m", NULL
51844 };
51845
51846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51848 if (!SWIG_IsOK(res1)) {
51849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51850 }
51851 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51852 ecode2 = SWIG_AsVal_int(obj1, &val2);
51853 if (!SWIG_IsOK(ecode2)) {
51854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51855 }
51856 arg2 = static_cast< int >(val2);
51857 {
51858 PyThreadState* __tstate = wxPyBeginAllowThreads();
51859 (arg1)->SetMargin(arg2);
51860 wxPyEndAllowThreads(__tstate);
51861 if (PyErr_Occurred()) SWIG_fail;
51862 }
51863 resultobj = SWIG_Py_Void();
51864 return resultobj;
51865 fail:
51866 return NULL;
51867 }
51868
51869
51870 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51871 PyObject *resultobj = 0;
51872 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51873 int result;
51874 void *argp1 = 0 ;
51875 int res1 = 0 ;
51876 PyObject *swig_obj[1] ;
51877
51878 if (!args) SWIG_fail;
51879 swig_obj[0] = args;
51880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51881 if (!SWIG_IsOK(res1)) {
51882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51883 }
51884 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51885 {
51886 PyThreadState* __tstate = wxPyBeginAllowThreads();
51887 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51888 wxPyEndAllowThreads(__tstate);
51889 if (PyErr_Occurred()) SWIG_fail;
51890 }
51891 resultobj = SWIG_From_int(static_cast< int >(result));
51892 return resultobj;
51893 fail:
51894 return NULL;
51895 }
51896
51897
51898 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51899 PyObject *resultobj = 0;
51900 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51901 int result;
51902 void *argp1 = 0 ;
51903 int res1 = 0 ;
51904 PyObject *swig_obj[1] ;
51905
51906 if (!args) SWIG_fail;
51907 swig_obj[0] = args;
51908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51909 if (!SWIG_IsOK(res1)) {
51910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51911 }
51912 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51913 {
51914 PyThreadState* __tstate = wxPyBeginAllowThreads();
51915 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51916 wxPyEndAllowThreads(__tstate);
51917 if (PyErr_Occurred()) SWIG_fail;
51918 }
51919 resultobj = SWIG_From_int(static_cast< int >(result));
51920 return resultobj;
51921 fail:
51922 return NULL;
51923 }
51924
51925
51926 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51927 PyObject *resultobj = 0;
51928 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51929 int result;
51930 void *argp1 = 0 ;
51931 int res1 = 0 ;
51932 PyObject *swig_obj[1] ;
51933
51934 if (!args) SWIG_fail;
51935 swig_obj[0] = args;
51936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51937 if (!SWIG_IsOK(res1)) {
51938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51939 }
51940 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51941 {
51942 PyThreadState* __tstate = wxPyBeginAllowThreads();
51943 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51944 wxPyEndAllowThreads(__tstate);
51945 if (PyErr_Occurred()) SWIG_fail;
51946 }
51947 resultobj = SWIG_From_int(static_cast< int >(result));
51948 return resultobj;
51949 fail:
51950 return NULL;
51951 }
51952
51953
51954 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51955 PyObject *resultobj = 0;
51956 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51957 bool result;
51958 void *argp1 = 0 ;
51959 int res1 = 0 ;
51960 PyObject *swig_obj[1] ;
51961
51962 if (!args) SWIG_fail;
51963 swig_obj[0] = args;
51964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51965 if (!SWIG_IsOK(res1)) {
51966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51967 }
51968 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51969 {
51970 PyThreadState* __tstate = wxPyBeginAllowThreads();
51971 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51972 wxPyEndAllowThreads(__tstate);
51973 if (PyErr_Occurred()) SWIG_fail;
51974 }
51975 {
51976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51977 }
51978 return resultobj;
51979 fail:
51980 return NULL;
51981 }
51982
51983
51984 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51985 PyObject *resultobj = 0;
51986 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51987 bool arg2 ;
51988 void *argp1 = 0 ;
51989 int res1 = 0 ;
51990 bool val2 ;
51991 int ecode2 = 0 ;
51992 PyObject * obj0 = 0 ;
51993 PyObject * obj1 = 0 ;
51994 char * kwnames[] = {
51995 (char *) "self",(char *) "d", NULL
51996 };
51997
51998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52000 if (!SWIG_IsOK(res1)) {
52001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52002 }
52003 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52004 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52005 if (!SWIG_IsOK(ecode2)) {
52006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52007 }
52008 arg2 = static_cast< bool >(val2);
52009 {
52010 PyThreadState* __tstate = wxPyBeginAllowThreads();
52011 (arg1)->SetDone(arg2);
52012 wxPyEndAllowThreads(__tstate);
52013 if (PyErr_Occurred()) SWIG_fail;
52014 }
52015 resultobj = SWIG_Py_Void();
52016 return resultobj;
52017 fail:
52018 return NULL;
52019 }
52020
52021
52022 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52023 PyObject *resultobj = 0;
52024 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52025 wxRelationship result;
52026 void *argp1 = 0 ;
52027 int res1 = 0 ;
52028 PyObject *swig_obj[1] ;
52029
52030 if (!args) SWIG_fail;
52031 swig_obj[0] = args;
52032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52033 if (!SWIG_IsOK(res1)) {
52034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52035 }
52036 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52037 {
52038 PyThreadState* __tstate = wxPyBeginAllowThreads();
52039 result = (wxRelationship)(arg1)->GetRelationship();
52040 wxPyEndAllowThreads(__tstate);
52041 if (PyErr_Occurred()) SWIG_fail;
52042 }
52043 resultobj = SWIG_From_int(static_cast< int >(result));
52044 return resultobj;
52045 fail:
52046 return NULL;
52047 }
52048
52049
52050 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52051 PyObject *resultobj = 0;
52052 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52053 wxRelationship arg2 ;
52054 void *argp1 = 0 ;
52055 int res1 = 0 ;
52056 int val2 ;
52057 int ecode2 = 0 ;
52058 PyObject * obj0 = 0 ;
52059 PyObject * obj1 = 0 ;
52060 char * kwnames[] = {
52061 (char *) "self",(char *) "r", NULL
52062 };
52063
52064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52066 if (!SWIG_IsOK(res1)) {
52067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52068 }
52069 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52070 ecode2 = SWIG_AsVal_int(obj1, &val2);
52071 if (!SWIG_IsOK(ecode2)) {
52072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52073 }
52074 arg2 = static_cast< wxRelationship >(val2);
52075 {
52076 PyThreadState* __tstate = wxPyBeginAllowThreads();
52077 (arg1)->SetRelationship(arg2);
52078 wxPyEndAllowThreads(__tstate);
52079 if (PyErr_Occurred()) SWIG_fail;
52080 }
52081 resultobj = SWIG_Py_Void();
52082 return resultobj;
52083 fail:
52084 return NULL;
52085 }
52086
52087
52088 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52089 PyObject *resultobj = 0;
52090 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52091 wxWindow *arg2 = (wxWindow *) 0 ;
52092 bool result;
52093 void *argp1 = 0 ;
52094 int res1 = 0 ;
52095 void *argp2 = 0 ;
52096 int res2 = 0 ;
52097 PyObject * obj0 = 0 ;
52098 PyObject * obj1 = 0 ;
52099 char * kwnames[] = {
52100 (char *) "self",(char *) "otherW", NULL
52101 };
52102
52103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52105 if (!SWIG_IsOK(res1)) {
52106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52107 }
52108 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52109 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52110 if (!SWIG_IsOK(res2)) {
52111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52112 }
52113 arg2 = reinterpret_cast< wxWindow * >(argp2);
52114 {
52115 PyThreadState* __tstate = wxPyBeginAllowThreads();
52116 result = (bool)(arg1)->ResetIfWin(arg2);
52117 wxPyEndAllowThreads(__tstate);
52118 if (PyErr_Occurred()) SWIG_fail;
52119 }
52120 {
52121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52122 }
52123 return resultobj;
52124 fail:
52125 return NULL;
52126 }
52127
52128
52129 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52130 PyObject *resultobj = 0;
52131 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52132 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52133 wxWindow *arg3 = (wxWindow *) 0 ;
52134 bool result;
52135 void *argp1 = 0 ;
52136 int res1 = 0 ;
52137 void *argp2 = 0 ;
52138 int res2 = 0 ;
52139 void *argp3 = 0 ;
52140 int res3 = 0 ;
52141 PyObject * obj0 = 0 ;
52142 PyObject * obj1 = 0 ;
52143 PyObject * obj2 = 0 ;
52144 char * kwnames[] = {
52145 (char *) "self",(char *) "constraints",(char *) "win", NULL
52146 };
52147
52148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52150 if (!SWIG_IsOK(res1)) {
52151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52152 }
52153 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52155 if (!SWIG_IsOK(res2)) {
52156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52157 }
52158 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52159 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52160 if (!SWIG_IsOK(res3)) {
52161 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52162 }
52163 arg3 = reinterpret_cast< wxWindow * >(argp3);
52164 {
52165 PyThreadState* __tstate = wxPyBeginAllowThreads();
52166 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52167 wxPyEndAllowThreads(__tstate);
52168 if (PyErr_Occurred()) SWIG_fail;
52169 }
52170 {
52171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52172 }
52173 return resultobj;
52174 fail:
52175 return NULL;
52176 }
52177
52178
52179 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52180 PyObject *resultobj = 0;
52181 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52182 wxEdge arg2 ;
52183 wxWindow *arg3 = (wxWindow *) 0 ;
52184 wxWindow *arg4 = (wxWindow *) 0 ;
52185 int result;
52186 void *argp1 = 0 ;
52187 int res1 = 0 ;
52188 int val2 ;
52189 int ecode2 = 0 ;
52190 void *argp3 = 0 ;
52191 int res3 = 0 ;
52192 void *argp4 = 0 ;
52193 int res4 = 0 ;
52194 PyObject * obj0 = 0 ;
52195 PyObject * obj1 = 0 ;
52196 PyObject * obj2 = 0 ;
52197 PyObject * obj3 = 0 ;
52198 char * kwnames[] = {
52199 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52200 };
52201
52202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52204 if (!SWIG_IsOK(res1)) {
52205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52206 }
52207 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52208 ecode2 = SWIG_AsVal_int(obj1, &val2);
52209 if (!SWIG_IsOK(ecode2)) {
52210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52211 }
52212 arg2 = static_cast< wxEdge >(val2);
52213 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52214 if (!SWIG_IsOK(res3)) {
52215 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52216 }
52217 arg3 = reinterpret_cast< wxWindow * >(argp3);
52218 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52219 if (!SWIG_IsOK(res4)) {
52220 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52221 }
52222 arg4 = reinterpret_cast< wxWindow * >(argp4);
52223 {
52224 PyThreadState* __tstate = wxPyBeginAllowThreads();
52225 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52226 wxPyEndAllowThreads(__tstate);
52227 if (PyErr_Occurred()) SWIG_fail;
52228 }
52229 resultobj = SWIG_From_int(static_cast< int >(result));
52230 return resultobj;
52231 fail:
52232 return NULL;
52233 }
52234
52235
52236 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52237 PyObject *obj;
52238 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52239 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52240 return SWIG_Py_Void();
52241 }
52242
52243 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52244 PyObject *resultobj = 0;
52245 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52246 wxIndividualLayoutConstraint *result = 0 ;
52247 void *argp1 = 0 ;
52248 int res1 = 0 ;
52249 PyObject *swig_obj[1] ;
52250
52251 if (!args) SWIG_fail;
52252 swig_obj[0] = args;
52253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52254 if (!SWIG_IsOK(res1)) {
52255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52256 }
52257 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52258 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52260 return resultobj;
52261 fail:
52262 return NULL;
52263 }
52264
52265
52266 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52267 PyObject *resultobj = 0;
52268 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52269 wxIndividualLayoutConstraint *result = 0 ;
52270 void *argp1 = 0 ;
52271 int res1 = 0 ;
52272 PyObject *swig_obj[1] ;
52273
52274 if (!args) SWIG_fail;
52275 swig_obj[0] = args;
52276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52277 if (!SWIG_IsOK(res1)) {
52278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52279 }
52280 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52281 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52283 return resultobj;
52284 fail:
52285 return NULL;
52286 }
52287
52288
52289 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52290 PyObject *resultobj = 0;
52291 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52292 wxIndividualLayoutConstraint *result = 0 ;
52293 void *argp1 = 0 ;
52294 int res1 = 0 ;
52295 PyObject *swig_obj[1] ;
52296
52297 if (!args) SWIG_fail;
52298 swig_obj[0] = args;
52299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52300 if (!SWIG_IsOK(res1)) {
52301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52302 }
52303 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52304 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52306 return resultobj;
52307 fail:
52308 return NULL;
52309 }
52310
52311
52312 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52313 PyObject *resultobj = 0;
52314 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52315 wxIndividualLayoutConstraint *result = 0 ;
52316 void *argp1 = 0 ;
52317 int res1 = 0 ;
52318 PyObject *swig_obj[1] ;
52319
52320 if (!args) SWIG_fail;
52321 swig_obj[0] = args;
52322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52323 if (!SWIG_IsOK(res1)) {
52324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52325 }
52326 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52327 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52329 return resultobj;
52330 fail:
52331 return NULL;
52332 }
52333
52334
52335 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52336 PyObject *resultobj = 0;
52337 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52338 wxIndividualLayoutConstraint *result = 0 ;
52339 void *argp1 = 0 ;
52340 int res1 = 0 ;
52341 PyObject *swig_obj[1] ;
52342
52343 if (!args) SWIG_fail;
52344 swig_obj[0] = args;
52345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52346 if (!SWIG_IsOK(res1)) {
52347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52348 }
52349 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52350 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52352 return resultobj;
52353 fail:
52354 return NULL;
52355 }
52356
52357
52358 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52359 PyObject *resultobj = 0;
52360 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52361 wxIndividualLayoutConstraint *result = 0 ;
52362 void *argp1 = 0 ;
52363 int res1 = 0 ;
52364 PyObject *swig_obj[1] ;
52365
52366 if (!args) SWIG_fail;
52367 swig_obj[0] = args;
52368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52369 if (!SWIG_IsOK(res1)) {
52370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52371 }
52372 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52373 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52375 return resultobj;
52376 fail:
52377 return NULL;
52378 }
52379
52380
52381 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52382 PyObject *resultobj = 0;
52383 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52384 wxIndividualLayoutConstraint *result = 0 ;
52385 void *argp1 = 0 ;
52386 int res1 = 0 ;
52387 PyObject *swig_obj[1] ;
52388
52389 if (!args) SWIG_fail;
52390 swig_obj[0] = args;
52391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52392 if (!SWIG_IsOK(res1)) {
52393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52394 }
52395 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52396 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52398 return resultobj;
52399 fail:
52400 return NULL;
52401 }
52402
52403
52404 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52405 PyObject *resultobj = 0;
52406 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52407 wxIndividualLayoutConstraint *result = 0 ;
52408 void *argp1 = 0 ;
52409 int res1 = 0 ;
52410 PyObject *swig_obj[1] ;
52411
52412 if (!args) SWIG_fail;
52413 swig_obj[0] = args;
52414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52415 if (!SWIG_IsOK(res1)) {
52416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52417 }
52418 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52419 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52421 return resultobj;
52422 fail:
52423 return NULL;
52424 }
52425
52426
52427 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52428 PyObject *resultobj = 0;
52429 wxLayoutConstraints *result = 0 ;
52430
52431 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52432 {
52433 PyThreadState* __tstate = wxPyBeginAllowThreads();
52434 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52435 wxPyEndAllowThreads(__tstate);
52436 if (PyErr_Occurred()) SWIG_fail;
52437 }
52438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52439 return resultobj;
52440 fail:
52441 return NULL;
52442 }
52443
52444
52445 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52446 PyObject *resultobj = 0;
52447 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52448 void *argp1 = 0 ;
52449 int res1 = 0 ;
52450 PyObject *swig_obj[1] ;
52451
52452 if (!args) SWIG_fail;
52453 swig_obj[0] = args;
52454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52455 if (!SWIG_IsOK(res1)) {
52456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52457 }
52458 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52459 {
52460 PyThreadState* __tstate = wxPyBeginAllowThreads();
52461 delete arg1;
52462
52463 wxPyEndAllowThreads(__tstate);
52464 if (PyErr_Occurred()) SWIG_fail;
52465 }
52466 resultobj = SWIG_Py_Void();
52467 return resultobj;
52468 fail:
52469 return NULL;
52470 }
52471
52472
52473 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52474 PyObject *resultobj = 0;
52475 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52476 wxWindow *arg2 = (wxWindow *) 0 ;
52477 int *arg3 = (int *) 0 ;
52478 bool result;
52479 void *argp1 = 0 ;
52480 int res1 = 0 ;
52481 void *argp2 = 0 ;
52482 int res2 = 0 ;
52483 int temp3 ;
52484 int res3 = SWIG_TMPOBJ ;
52485 PyObject * obj0 = 0 ;
52486 PyObject * obj1 = 0 ;
52487 char * kwnames[] = {
52488 (char *) "self",(char *) "win", NULL
52489 };
52490
52491 arg3 = &temp3;
52492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52494 if (!SWIG_IsOK(res1)) {
52495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52496 }
52497 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52499 if (!SWIG_IsOK(res2)) {
52500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52501 }
52502 arg2 = reinterpret_cast< wxWindow * >(argp2);
52503 {
52504 PyThreadState* __tstate = wxPyBeginAllowThreads();
52505 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52506 wxPyEndAllowThreads(__tstate);
52507 if (PyErr_Occurred()) SWIG_fail;
52508 }
52509 {
52510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52511 }
52512 if (SWIG_IsTmpObj(res3)) {
52513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52514 } else {
52515 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52517 }
52518 return resultobj;
52519 fail:
52520 return NULL;
52521 }
52522
52523
52524 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52525 PyObject *resultobj = 0;
52526 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52527 bool result;
52528 void *argp1 = 0 ;
52529 int res1 = 0 ;
52530 PyObject *swig_obj[1] ;
52531
52532 if (!args) SWIG_fail;
52533 swig_obj[0] = args;
52534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52535 if (!SWIG_IsOK(res1)) {
52536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52537 }
52538 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52539 {
52540 PyThreadState* __tstate = wxPyBeginAllowThreads();
52541 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52542 wxPyEndAllowThreads(__tstate);
52543 if (PyErr_Occurred()) SWIG_fail;
52544 }
52545 {
52546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52547 }
52548 return resultobj;
52549 fail:
52550 return NULL;
52551 }
52552
52553
52554 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52555 PyObject *obj;
52556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52557 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52558 return SWIG_Py_Void();
52559 }
52560
52561 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52562 return SWIG_Python_InitShadowInstance(args);
52563 }
52564
52565 static PyMethodDef SwigMethods[] = {
52566 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52567 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52568 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52569 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52570 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52571 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52572 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52573 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52574 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52576 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52577 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52578 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52580 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52586 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52587 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52588 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52590 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52591 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52592 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52593 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52594 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52595 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52596 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52598 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52603 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52604 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52605 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52606 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52607 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52608 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52609 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52610 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52612 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52613 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52616 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52620 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52621 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52622 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52627 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52628 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52630 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52631 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52632 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52633 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52634 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52636 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52638 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52640 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52641 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52643 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52645 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52646 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52647 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52648 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52667 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52668 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52669 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52670 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52671 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52672 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52673 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52674 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52676 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52677 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52678 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52683 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52684 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52685 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52686 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52693 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52695 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52696 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52697 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52698 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52700 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52701 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52702 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52703 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52705 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52706 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52707 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52708 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52709 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52710 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52711 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52712 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52717 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52718 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52719 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52720 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52721 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52722 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52723 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52725 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52726 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52727 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52728 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52729 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52730 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52731 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52732 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52733 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52734 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52735 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52736 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52737 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52738 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52739 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52740 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52741 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52742 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52747 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52753 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52754 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52755 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52756 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52758 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52761 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52763 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52766 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52767 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52768 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52771 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52772 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52773 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52777 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52778 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52779 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52783 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52788 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52789 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52790 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52791 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52792 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52793 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52794 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52800 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52801 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52803 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52804 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52805 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52811 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52812 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52814 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52815 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52816 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52817 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52818 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52819 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52820 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52821 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52823 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52824 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52825 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52826 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52827 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52828 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52829 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52830 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52832 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52841 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52853 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52854 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52869 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52870 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52871 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52872 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52875 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52877 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52879 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52881 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52883 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52886 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52887 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52888 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52889 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52891 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52908 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52909 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52915 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52916 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52917 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52918 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52919 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52920 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52921 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52922 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52923 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52924 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52925 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52926 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52927 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52928 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52929 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52930 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52931 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52932 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52933 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52934 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52935 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52936 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52937 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52938 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52939 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52940 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52941 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52942 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52943 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52944 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52945 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52946 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52947 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52948 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52949 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52951 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52952 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52953 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52954 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52957 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52961 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52965 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52966 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52967 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52968 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52970 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52971 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52973 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52975 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52977 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52979 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52980 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52981 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52983 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52984 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52986 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52987 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52988 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52990 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52991 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52992 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52994 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52996 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52997 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52998 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53000 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53002 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53003 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53005 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53006 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53007 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53009 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53010 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53011 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53012 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53013 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53015 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53016 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53019 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53020 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53022 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53023 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53026 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53027 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53029 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53035 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53036 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53037 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53038 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53039 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53040 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53041 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53042 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53043 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53044 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53045 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53046 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53047 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53048 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53049 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53050 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53051 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53052 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53053 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53054 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53055 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53056 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53057 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53058 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53060 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53061 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53062 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53063 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53064 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53065 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53066 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53067 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53068 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53069 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53070 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53071 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53072 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53073 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53074 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53075 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53076 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53077 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53078 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53079 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53080 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53081 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53082 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53083 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53084 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53085 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53086 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53087 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53088 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53089 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53090 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53091 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53093 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53094 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53096 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53097 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53098 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53099 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53101 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53102 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53103 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53104 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53105 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53106 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53107 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53108 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53109 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53110 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53111 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53112 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53113 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53114 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53115 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53116 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53117 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53118 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53119 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53120 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53121 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53122 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53123 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53124 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53125 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53126 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53127 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53128 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53129 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53130 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53131 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53132 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53133 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53134 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53135 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53136 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53137 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53139 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53140 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53143 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53144 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53145 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53146 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53147 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53148 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53150 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53151 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53154 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53155 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53157 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53158 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53160 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53161 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53163 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53164 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53165 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53167 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53169 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53170 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53172 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53173 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53174 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53176 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53177 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53178 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53180 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53181 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53183 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53184 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53185 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53186 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53187 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53190 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53192 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53194 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53195 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53196 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53199 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53200 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53201 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53203 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53204 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53205 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53207 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53208 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53209 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53210 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53211 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53212 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53214 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53215 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53216 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53217 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53218 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53219 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53220 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53221 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53227 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53229 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53231 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53232 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53233 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53234 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53235 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53236 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53238 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53239 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53240 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53241 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53242 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53243 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53246 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53247 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53248 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53251 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53252 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53253 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53254 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53255 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53257 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53259 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53262 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53264 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53265 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53267 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53268 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53269 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53271 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53272 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53273 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53275 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53277 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53278 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53279 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53281 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53283 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53285 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53286 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53288 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53289 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53291 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53293 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53294 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53295 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53297 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53299 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53300 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53301 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53303 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53305 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53306 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53307 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53308 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53310 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53312 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53314 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53316 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53317 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53319 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53320 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53321 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53322 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53323 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53324 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53325 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53326 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53328 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53330 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53332 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53334 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53336 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53338 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53339 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53340 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53341 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53342 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53343 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53349 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53350 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53351 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53352 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53353 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53354 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53355 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53357 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53359 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53360 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53362 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53363 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53364 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53365 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53367 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53368 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53369 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53370 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53372 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53373 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53375 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53376 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53377 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53379 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53381 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53382 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53383 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53384 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53385 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53387 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53388 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53389 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53390 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53392 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53393 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53394 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53395 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53396 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53397 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53398 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53399 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53400 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53401 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53403 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53406 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53407 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53408 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53410 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53412 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53414 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53416 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53417 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53427 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53428 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53432 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53433 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53434 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53435 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53436 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53437 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53438 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53439 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53440 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53441 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53442 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53443 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53444 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53445 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53446 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53448 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53449 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53452 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53453 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53458 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53459 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53462 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53463 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53464 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53465 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53468 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53469 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53470 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53472 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53474 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53475 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53476 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53478 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53480 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53482 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53485 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53486 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53487 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53488 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53489 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53490 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53491 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53497 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53498 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53499 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53500 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53507 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53513 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53514 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53515 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53516 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53517 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53519 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53529 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53530 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53531 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53532 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53535 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53536 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53537 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53538 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53540 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53541 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53545 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53551 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53552 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53553 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53554 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53556 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53557 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53559 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53562 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53564 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53565 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53566 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53575 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53579 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53581 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53591 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53592 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53593 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53594 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53597 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53600 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53602 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53605 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53607 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53608 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53611 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53613 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53614 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53615 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53616 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53617 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53622 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53623 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53624 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53626 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53627 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53628 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53630 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53632 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53633 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53634 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53636 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53637 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53640 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53648 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53655 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53663 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53666 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53667 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53680 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53682 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53684 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53685 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53687 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53689 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53690 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53692 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53693 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53694 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53698 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53717 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53718 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53720 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53722 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53723 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53724 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53726 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53727 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53730 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53731 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53733 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53734 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53736 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53739 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53740 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53742 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53744 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53746 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53747 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53749 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53750 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53753 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53755 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53757 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53759 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53762 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53764 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53765 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53766 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53768 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53769 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53770 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53772 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53775 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53777 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53778 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53782 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53786 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53787 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53789 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53793 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53795 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53797 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53798 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53799 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53800 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53804 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53805 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53806 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53807 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53809 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53810 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53815 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53816 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53817 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53818 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53819 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53821 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53823 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53825 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53826 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53828 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53830 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53833 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53834 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53835 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53837 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53838 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53839 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53853 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53854 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53855 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53856 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53857 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53858 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53864 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53865 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53869 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53870 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53872 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53873 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53875 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53877 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53878 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53880 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53881 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53882 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53888 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53889 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53890 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53891 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53892 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53893 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53900 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53902 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53903 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53904 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53905 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53906 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53907 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53909 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53913 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53914 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53915 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53916 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53917 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53918 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53919 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53921 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53922 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53923 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53929 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53930 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53931 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53933 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53934 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53935 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53941 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53942 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53943 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53944 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53945 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53949 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53950 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53955 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53956 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53958 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53959 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53964 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53966 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53967 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53968 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53969 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53970 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53975 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53976 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53985 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53986 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53987 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53988 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53991 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53993 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53994 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53995 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53996 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53998 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54003 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54004 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54005 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54006 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54007 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54008 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54009 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54010 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54011 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54012 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54013 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54015 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54016 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54017 { NULL, NULL, 0, NULL }
54018 };
54019
54020
54021 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54022
54023 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54024 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54025 }
54026 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54027 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54028 }
54029 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54030 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54031 }
54032 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54033 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54034 }
54035 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54036 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54037 }
54038 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54039 return (void *)((wxSizer *) ((wxGridSizer *) x));
54040 }
54041 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54042 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54043 }
54044 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54045 return (void *)((wxSizer *) ((wxPySizer *) x));
54046 }
54047 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54048 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54049 }
54050 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54051 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54052 }
54053 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54054 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54055 }
54056 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54057 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54058 }
54059 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54060 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54061 }
54062 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54063 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54064 }
54065 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54066 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54067 }
54068 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54069 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54070 }
54071 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54072 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54073 }
54074 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54075 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54076 }
54077 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54078 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54079 }
54080 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54081 return (void *)((wxEvent *) ((wxPyEvent *) x));
54082 }
54083 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54084 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54085 }
54086 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54087 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54088 }
54089 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54090 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54091 }
54092 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54093 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54094 }
54095 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54096 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54097 }
54098 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54099 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54100 }
54101 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54102 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54103 }
54104 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54105 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54106 }
54107 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54108 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54109 }
54110 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54111 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54112 }
54113 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54114 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54115 }
54116 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54117 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54118 }
54119 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54120 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54121 }
54122 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54123 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54124 }
54125 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54126 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54127 }
54128 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54129 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54130 }
54131 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54132 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54133 }
54134 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54135 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54136 }
54137 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54138 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54139 }
54140 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54141 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54142 }
54143 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54144 return (void *)((wxEvent *) ((wxShowEvent *) x));
54145 }
54146 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54147 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54148 }
54149 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54150 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54151 }
54152 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54153 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54154 }
54155 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54156 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54157 }
54158 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54159 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54160 }
54161 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54162 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54163 }
54164 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54165 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54166 }
54167 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54168 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54169 }
54170 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54171 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54172 }
54173 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54174 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54175 }
54176 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54177 return (void *)((wxControl *) ((wxControlWithItems *) x));
54178 }
54179 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54180 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54181 }
54182 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54183 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54184 }
54185 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54186 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54187 }
54188 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54189 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54190 }
54191 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54192 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54193 }
54194 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54195 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54196 }
54197 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54198 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54199 }
54200 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54201 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54202 }
54203 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54204 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54205 }
54206 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54207 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54208 }
54209 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54210 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54211 }
54212 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54213 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54214 }
54215 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54216 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54217 }
54218 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54219 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54220 }
54221 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54222 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54223 }
54224 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54225 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54226 }
54227 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54228 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54229 }
54230 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54231 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54232 }
54233 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54234 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54235 }
54236 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54237 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54238 }
54239 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54240 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54241 }
54242 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54243 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54244 }
54245 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54246 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54247 }
54248 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54249 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54250 }
54251 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54252 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54253 }
54254 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54255 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54256 }
54257 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54258 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54259 }
54260 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54261 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54262 }
54263 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54264 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54265 }
54266 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54267 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54268 }
54269 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54270 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54271 }
54272 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54273 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54274 }
54275 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54276 return (void *)((wxObject *) ((wxSizerItem *) x));
54277 }
54278 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54279 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54280 }
54281 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54282 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54283 }
54284 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54285 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54286 }
54287 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54288 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54289 }
54290 static void *_p_wxSizerTo_p_wxObject(void *x) {
54291 return (void *)((wxObject *) ((wxSizer *) x));
54292 }
54293 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54294 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54295 }
54296 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54297 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54298 }
54299 static void *_p_wxEventTo_p_wxObject(void *x) {
54300 return (void *)((wxObject *) ((wxEvent *) x));
54301 }
54302 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54303 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54304 }
54305 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54306 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54307 }
54308 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54309 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54310 }
54311 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54312 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54313 }
54314 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54315 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54316 }
54317 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54318 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54319 }
54320 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54321 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54322 }
54323 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54324 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54325 }
54326 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54327 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54328 }
54329 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54330 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54331 }
54332 static void *_p_wxControlTo_p_wxObject(void *x) {
54333 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54334 }
54335 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54336 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54337 }
54338 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54339 return (void *)((wxObject *) ((wxFSFile *) x));
54340 }
54341 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54342 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54343 }
54344 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54345 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54346 }
54347 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54348 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54349 }
54350 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54351 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54352 }
54353 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54354 return (void *)((wxObject *) ((wxMenuItem *) x));
54355 }
54356 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54357 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54358 }
54359 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54360 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54361 }
54362 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54363 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54364 }
54365 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54366 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54367 }
54368 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54369 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54370 }
54371 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54372 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54373 }
54374 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54375 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54376 }
54377 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54378 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54379 }
54380 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54381 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54382 }
54383 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54384 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54385 }
54386 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54387 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54388 }
54389 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54390 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54391 }
54392 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54393 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54394 }
54395 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54396 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54397 }
54398 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54399 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54400 }
54401 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54402 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54403 }
54404 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54405 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54406 }
54407 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54408 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54409 }
54410 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54411 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54412 }
54413 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54414 return (void *)((wxObject *) ((wxImageHandler *) x));
54415 }
54416 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54417 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54418 }
54419 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54420 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54421 }
54422 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54423 return (void *)((wxObject *) ((wxEvtHandler *) x));
54424 }
54425 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54426 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54427 }
54428 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54429 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54430 }
54431 static void *_p_wxImageTo_p_wxObject(void *x) {
54432 return (void *)((wxObject *) ((wxImage *) x));
54433 }
54434 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54435 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54436 }
54437 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54438 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54439 }
54440 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54441 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54442 }
54443 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54444 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54445 }
54446 static void *_p_wxWindowTo_p_wxObject(void *x) {
54447 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54448 }
54449 static void *_p_wxMenuTo_p_wxObject(void *x) {
54450 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54451 }
54452 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54453 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54454 }
54455 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54456 return (void *)((wxObject *) ((wxFileSystem *) x));
54457 }
54458 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54459 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54460 }
54461 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54462 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54463 }
54464 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54465 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54466 }
54467 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54468 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54469 }
54470 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54471 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54472 }
54473 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54474 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54475 }
54476 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54477 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54478 }
54479 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54480 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54481 }
54482 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54483 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54484 }
54485 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54486 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54487 }
54488 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54489 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54490 }
54491 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54492 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54493 }
54494 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54495 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54496 }
54497 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54498 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54499 }
54500 static void *_p_wxControlTo_p_wxWindow(void *x) {
54501 return (void *)((wxWindow *) ((wxControl *) x));
54502 }
54503 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54504 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54505 }
54506 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54507 return (void *)((wxWindow *) ((wxMenuBar *) x));
54508 }
54509 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54510 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54511 }
54512 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54513 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54514 }
54515 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54516 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54517 }
54518 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54519 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54520 }
54521 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54522 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54523 }
54524 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54525 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54526 }
54527 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54528 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54529 }
54530 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54531 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54532 }
54533 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54534 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54535 }
54536 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54537 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54538 }
54539 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54540 return (void *)((wxValidator *) ((wxPyValidator *) x));
54541 }
54542 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54543 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54544 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};
54545 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54562 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54563 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54564 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54565 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54566 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54567 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54568 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54569 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54570 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54571 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54572 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54573 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54574 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54575 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54576 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54577 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54578 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54579 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54580 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54581 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54582 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54583 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54584 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54585 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54586 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54587 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54588 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54589 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54590 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54591 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54592 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54593 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54594 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54595 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54596 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54597 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54598 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54599 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54600 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54601 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54602 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54603 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54604 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54605 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54606 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54607 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54608 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54609 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54610 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54611 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54612 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54613 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54614 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54615 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54616 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54617 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54618 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54619 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54620 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54621 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54622 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54623 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54624 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54625 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54626 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54627 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54628 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54629 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54630 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54631 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54632 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54633 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54634 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54635 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54636 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54637 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54638 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54639 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54640 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54641 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54642 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54643 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54644 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54645 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54646 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54647 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54648 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54649 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54650 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54651 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54652 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54653 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54654 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54655 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54656 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54657 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54658 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54659 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54660 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54661 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54662 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54663 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54664 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54665 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54666 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54667 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54668 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54669 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54670 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54671 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54672
54673 static swig_type_info *swig_type_initial[] = {
54674 &_swigt__p_buffer,
54675 &_swigt__p_char,
54676 &_swigt__p_form_ops_t,
54677 &_swigt__p_int,
54678 &_swigt__p_long,
54679 &_swigt__p_unsigned_char,
54680 &_swigt__p_unsigned_int,
54681 &_swigt__p_unsigned_long,
54682 &_swigt__p_wxANIHandler,
54683 &_swigt__p_wxAcceleratorEntry,
54684 &_swigt__p_wxAcceleratorTable,
54685 &_swigt__p_wxActivateEvent,
54686 &_swigt__p_wxAppTraits,
54687 &_swigt__p_wxArrayString,
54688 &_swigt__p_wxBMPHandler,
54689 &_swigt__p_wxBitmap,
54690 &_swigt__p_wxBoxSizer,
54691 &_swigt__p_wxButton,
54692 &_swigt__p_wxCURHandler,
54693 &_swigt__p_wxCaret,
54694 &_swigt__p_wxChildFocusEvent,
54695 &_swigt__p_wxClipboardTextEvent,
54696 &_swigt__p_wxCloseEvent,
54697 &_swigt__p_wxColour,
54698 &_swigt__p_wxCommandEvent,
54699 &_swigt__p_wxContextMenuEvent,
54700 &_swigt__p_wxControl,
54701 &_swigt__p_wxControlWithItems,
54702 &_swigt__p_wxCursor,
54703 &_swigt__p_wxDC,
54704 &_swigt__p_wxDateEvent,
54705 &_swigt__p_wxDateTime,
54706 &_swigt__p_wxDisplayChangedEvent,
54707 &_swigt__p_wxDropFilesEvent,
54708 &_swigt__p_wxDuplexMode,
54709 &_swigt__p_wxEraseEvent,
54710 &_swigt__p_wxEvent,
54711 &_swigt__p_wxEventLoop,
54712 &_swigt__p_wxEventLoopActivator,
54713 &_swigt__p_wxEvtHandler,
54714 &_swigt__p_wxFSFile,
54715 &_swigt__p_wxFileSystem,
54716 &_swigt__p_wxFileSystemHandler,
54717 &_swigt__p_wxFlexGridSizer,
54718 &_swigt__p_wxFocusEvent,
54719 &_swigt__p_wxFont,
54720 &_swigt__p_wxFrame,
54721 &_swigt__p_wxGBPosition,
54722 &_swigt__p_wxGBSizerItem,
54723 &_swigt__p_wxGBSpan,
54724 &_swigt__p_wxGIFHandler,
54725 &_swigt__p_wxGridBagSizer,
54726 &_swigt__p_wxGridSizer,
54727 &_swigt__p_wxICOHandler,
54728 &_swigt__p_wxIconizeEvent,
54729 &_swigt__p_wxIdleEvent,
54730 &_swigt__p_wxImage,
54731 &_swigt__p_wxImageHandler,
54732 &_swigt__p_wxImageHistogram,
54733 &_swigt__p_wxImage_HSVValue,
54734 &_swigt__p_wxImage_RGBValue,
54735 &_swigt__p_wxIndividualLayoutConstraint,
54736 &_swigt__p_wxInitDialogEvent,
54737 &_swigt__p_wxInputStream,
54738 &_swigt__p_wxInternetFSHandler,
54739 &_swigt__p_wxItemContainer,
54740 &_swigt__p_wxJPEGHandler,
54741 &_swigt__p_wxKeyEvent,
54742 &_swigt__p_wxLayoutConstraints,
54743 &_swigt__p_wxMaximizeEvent,
54744 &_swigt__p_wxMemoryFSHandler,
54745 &_swigt__p_wxMenu,
54746 &_swigt__p_wxMenuBar,
54747 &_swigt__p_wxMenuBarBase,
54748 &_swigt__p_wxMenuEvent,
54749 &_swigt__p_wxMenuItem,
54750 &_swigt__p_wxMouseCaptureChangedEvent,
54751 &_swigt__p_wxMouseEvent,
54752 &_swigt__p_wxMoveEvent,
54753 &_swigt__p_wxNavigationKeyEvent,
54754 &_swigt__p_wxNcPaintEvent,
54755 &_swigt__p_wxNotifyEvent,
54756 &_swigt__p_wxObject,
54757 &_swigt__p_wxOutputStream,
54758 &_swigt__p_wxPCXHandler,
54759 &_swigt__p_wxPNGHandler,
54760 &_swigt__p_wxPNMHandler,
54761 &_swigt__p_wxPaintEvent,
54762 &_swigt__p_wxPaletteChangedEvent,
54763 &_swigt__p_wxPaperSize,
54764 &_swigt__p_wxPoint,
54765 &_swigt__p_wxPoint2D,
54766 &_swigt__p_wxPropagateOnce,
54767 &_swigt__p_wxPropagationDisabler,
54768 &_swigt__p_wxPyApp,
54769 &_swigt__p_wxPyCommandEvent,
54770 &_swigt__p_wxPyDropTarget,
54771 &_swigt__p_wxPyEvent,
54772 &_swigt__p_wxPyFileSystemHandler,
54773 &_swigt__p_wxPyImageHandler,
54774 &_swigt__p_wxPyInputStream,
54775 &_swigt__p_wxPySizer,
54776 &_swigt__p_wxPyValidator,
54777 &_swigt__p_wxQuantize,
54778 &_swigt__p_wxQueryNewPaletteEvent,
54779 &_swigt__p_wxRealPoint,
54780 &_swigt__p_wxRect,
54781 &_swigt__p_wxRegion,
54782 &_swigt__p_wxScrollEvent,
54783 &_swigt__p_wxScrollWinEvent,
54784 &_swigt__p_wxSetCursorEvent,
54785 &_swigt__p_wxShowEvent,
54786 &_swigt__p_wxSize,
54787 &_swigt__p_wxSizeEvent,
54788 &_swigt__p_wxSizer,
54789 &_swigt__p_wxSizerItem,
54790 &_swigt__p_wxStaticBox,
54791 &_swigt__p_wxStaticBoxSizer,
54792 &_swigt__p_wxStdDialogButtonSizer,
54793 &_swigt__p_wxSysColourChangedEvent,
54794 &_swigt__p_wxTIFFHandler,
54795 &_swigt__p_wxToolTip,
54796 &_swigt__p_wxUpdateUIEvent,
54797 &_swigt__p_wxValidator,
54798 &_swigt__p_wxVisualAttributes,
54799 &_swigt__p_wxWindow,
54800 &_swigt__p_wxWindowCreateEvent,
54801 &_swigt__p_wxWindowDestroyEvent,
54802 &_swigt__p_wxXPMHandler,
54803 &_swigt__p_wxZipFSHandler,
54804 };
54805
54806 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54807 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54808 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54809 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54810 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54811 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54812 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54813 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54816 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54817 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54818 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54819 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54820 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}};
54821 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54822 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}};
54823 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54824 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}};
54825 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54826 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54827 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54828 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54829 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54830 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}};
54831 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54832 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}};
54833 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54834 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54835 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54836 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54837 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54838 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54839 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54840 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54841 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54842 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_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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}};
54843 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54844 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54845 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}};
54846 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54847 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54848 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}};
54849 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}};
54850 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54851 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54852 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54853 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54854 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54855 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54856 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54857 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54858 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}};
54859 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}};
54860 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54861 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54862 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54863 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}};
54864 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54865 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54866 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54867 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54868 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54869 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54870 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54871 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}};
54872 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54873 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54874 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54875 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54876 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54877 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54878 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54879 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54880 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54881 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54882 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54883 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54884 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54885 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54886 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54887 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54888 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_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_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_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_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_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_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}};
54889 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54890 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54891 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54892 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54893 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54894 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54895 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54896 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54897 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54898 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54899 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54900 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54901 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54902 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54903 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54904 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54905 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54906 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54907 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54908 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54909 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54910 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54911 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54912 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54913 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54914 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54915 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54916 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54917 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54918 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54919 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54920 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}};
54921 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}};
54922 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54923 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54924 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54925 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54926 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54927 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54928 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54929 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}};
54930 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54931 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}};
54932 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54933 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54934 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54935 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54936
54937 static swig_cast_info *swig_cast_initial[] = {
54938 _swigc__p_buffer,
54939 _swigc__p_char,
54940 _swigc__p_form_ops_t,
54941 _swigc__p_int,
54942 _swigc__p_long,
54943 _swigc__p_unsigned_char,
54944 _swigc__p_unsigned_int,
54945 _swigc__p_unsigned_long,
54946 _swigc__p_wxANIHandler,
54947 _swigc__p_wxAcceleratorEntry,
54948 _swigc__p_wxAcceleratorTable,
54949 _swigc__p_wxActivateEvent,
54950 _swigc__p_wxAppTraits,
54951 _swigc__p_wxArrayString,
54952 _swigc__p_wxBMPHandler,
54953 _swigc__p_wxBitmap,
54954 _swigc__p_wxBoxSizer,
54955 _swigc__p_wxButton,
54956 _swigc__p_wxCURHandler,
54957 _swigc__p_wxCaret,
54958 _swigc__p_wxChildFocusEvent,
54959 _swigc__p_wxClipboardTextEvent,
54960 _swigc__p_wxCloseEvent,
54961 _swigc__p_wxColour,
54962 _swigc__p_wxCommandEvent,
54963 _swigc__p_wxContextMenuEvent,
54964 _swigc__p_wxControl,
54965 _swigc__p_wxControlWithItems,
54966 _swigc__p_wxCursor,
54967 _swigc__p_wxDC,
54968 _swigc__p_wxDateEvent,
54969 _swigc__p_wxDateTime,
54970 _swigc__p_wxDisplayChangedEvent,
54971 _swigc__p_wxDropFilesEvent,
54972 _swigc__p_wxDuplexMode,
54973 _swigc__p_wxEraseEvent,
54974 _swigc__p_wxEvent,
54975 _swigc__p_wxEventLoop,
54976 _swigc__p_wxEventLoopActivator,
54977 _swigc__p_wxEvtHandler,
54978 _swigc__p_wxFSFile,
54979 _swigc__p_wxFileSystem,
54980 _swigc__p_wxFileSystemHandler,
54981 _swigc__p_wxFlexGridSizer,
54982 _swigc__p_wxFocusEvent,
54983 _swigc__p_wxFont,
54984 _swigc__p_wxFrame,
54985 _swigc__p_wxGBPosition,
54986 _swigc__p_wxGBSizerItem,
54987 _swigc__p_wxGBSpan,
54988 _swigc__p_wxGIFHandler,
54989 _swigc__p_wxGridBagSizer,
54990 _swigc__p_wxGridSizer,
54991 _swigc__p_wxICOHandler,
54992 _swigc__p_wxIconizeEvent,
54993 _swigc__p_wxIdleEvent,
54994 _swigc__p_wxImage,
54995 _swigc__p_wxImageHandler,
54996 _swigc__p_wxImageHistogram,
54997 _swigc__p_wxImage_HSVValue,
54998 _swigc__p_wxImage_RGBValue,
54999 _swigc__p_wxIndividualLayoutConstraint,
55000 _swigc__p_wxInitDialogEvent,
55001 _swigc__p_wxInputStream,
55002 _swigc__p_wxInternetFSHandler,
55003 _swigc__p_wxItemContainer,
55004 _swigc__p_wxJPEGHandler,
55005 _swigc__p_wxKeyEvent,
55006 _swigc__p_wxLayoutConstraints,
55007 _swigc__p_wxMaximizeEvent,
55008 _swigc__p_wxMemoryFSHandler,
55009 _swigc__p_wxMenu,
55010 _swigc__p_wxMenuBar,
55011 _swigc__p_wxMenuBarBase,
55012 _swigc__p_wxMenuEvent,
55013 _swigc__p_wxMenuItem,
55014 _swigc__p_wxMouseCaptureChangedEvent,
55015 _swigc__p_wxMouseEvent,
55016 _swigc__p_wxMoveEvent,
55017 _swigc__p_wxNavigationKeyEvent,
55018 _swigc__p_wxNcPaintEvent,
55019 _swigc__p_wxNotifyEvent,
55020 _swigc__p_wxObject,
55021 _swigc__p_wxOutputStream,
55022 _swigc__p_wxPCXHandler,
55023 _swigc__p_wxPNGHandler,
55024 _swigc__p_wxPNMHandler,
55025 _swigc__p_wxPaintEvent,
55026 _swigc__p_wxPaletteChangedEvent,
55027 _swigc__p_wxPaperSize,
55028 _swigc__p_wxPoint,
55029 _swigc__p_wxPoint2D,
55030 _swigc__p_wxPropagateOnce,
55031 _swigc__p_wxPropagationDisabler,
55032 _swigc__p_wxPyApp,
55033 _swigc__p_wxPyCommandEvent,
55034 _swigc__p_wxPyDropTarget,
55035 _swigc__p_wxPyEvent,
55036 _swigc__p_wxPyFileSystemHandler,
55037 _swigc__p_wxPyImageHandler,
55038 _swigc__p_wxPyInputStream,
55039 _swigc__p_wxPySizer,
55040 _swigc__p_wxPyValidator,
55041 _swigc__p_wxQuantize,
55042 _swigc__p_wxQueryNewPaletteEvent,
55043 _swigc__p_wxRealPoint,
55044 _swigc__p_wxRect,
55045 _swigc__p_wxRegion,
55046 _swigc__p_wxScrollEvent,
55047 _swigc__p_wxScrollWinEvent,
55048 _swigc__p_wxSetCursorEvent,
55049 _swigc__p_wxShowEvent,
55050 _swigc__p_wxSize,
55051 _swigc__p_wxSizeEvent,
55052 _swigc__p_wxSizer,
55053 _swigc__p_wxSizerItem,
55054 _swigc__p_wxStaticBox,
55055 _swigc__p_wxStaticBoxSizer,
55056 _swigc__p_wxStdDialogButtonSizer,
55057 _swigc__p_wxSysColourChangedEvent,
55058 _swigc__p_wxTIFFHandler,
55059 _swigc__p_wxToolTip,
55060 _swigc__p_wxUpdateUIEvent,
55061 _swigc__p_wxValidator,
55062 _swigc__p_wxVisualAttributes,
55063 _swigc__p_wxWindow,
55064 _swigc__p_wxWindowCreateEvent,
55065 _swigc__p_wxWindowDestroyEvent,
55066 _swigc__p_wxXPMHandler,
55067 _swigc__p_wxZipFSHandler,
55068 };
55069
55070
55071 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55072
55073 static swig_const_info swig_const_table[] = {
55074 {0, 0, 0, 0.0, 0, 0}};
55075
55076 #ifdef __cplusplus
55077 }
55078 #endif
55079 /* -----------------------------------------------------------------------------
55080 * Type initialization:
55081 * This problem is tough by the requirement that no dynamic
55082 * memory is used. Also, since swig_type_info structures store pointers to
55083 * swig_cast_info structures and swig_cast_info structures store pointers back
55084 * to swig_type_info structures, we need some lookup code at initialization.
55085 * The idea is that swig generates all the structures that are needed.
55086 * The runtime then collects these partially filled structures.
55087 * The SWIG_InitializeModule function takes these initial arrays out of
55088 * swig_module, and does all the lookup, filling in the swig_module.types
55089 * array with the correct data and linking the correct swig_cast_info
55090 * structures together.
55091 *
55092 * The generated swig_type_info structures are assigned staticly to an initial
55093 * array. We just loop though that array, and handle each type individually.
55094 * First we lookup if this type has been already loaded, and if so, use the
55095 * loaded structure instead of the generated one. Then we have to fill in the
55096 * cast linked list. The cast data is initially stored in something like a
55097 * two-dimensional array. Each row corresponds to a type (there are the same
55098 * number of rows as there are in the swig_type_initial array). Each entry in
55099 * a column is one of the swig_cast_info structures for that type.
55100 * The cast_initial array is actually an array of arrays, because each row has
55101 * a variable number of columns. So to actually build the cast linked list,
55102 * we find the array of casts associated with the type, and loop through it
55103 * adding the casts to the list. The one last trick we need to do is making
55104 * sure the type pointer in the swig_cast_info struct is correct.
55105 *
55106 * First off, we lookup the cast->type name to see if it is already loaded.
55107 * There are three cases to handle:
55108 * 1) If the cast->type has already been loaded AND the type we are adding
55109 * casting info to has not been loaded (it is in this module), THEN we
55110 * replace the cast->type pointer with the type pointer that has already
55111 * been loaded.
55112 * 2) If BOTH types (the one we are adding casting info to, and the
55113 * cast->type) are loaded, THEN the cast info has already been loaded by
55114 * the previous module so we just ignore it.
55115 * 3) Finally, if cast->type has not already been loaded, then we add that
55116 * swig_cast_info to the linked list (because the cast->type) pointer will
55117 * be correct.
55118 * ----------------------------------------------------------------------------- */
55119
55120 #ifdef __cplusplus
55121 extern "C" {
55122 #if 0
55123 } /* c-mode */
55124 #endif
55125 #endif
55126
55127 #if 0
55128 #define SWIGRUNTIME_DEBUG
55129 #endif
55130
55131 SWIGRUNTIME void
55132 SWIG_InitializeModule(void *clientdata) {
55133 size_t i;
55134 swig_module_info *module_head;
55135 static int init_run = 0;
55136
55137 clientdata = clientdata;
55138
55139 if (init_run) return;
55140 init_run = 1;
55141
55142 /* Initialize the swig_module */
55143 swig_module.type_initial = swig_type_initial;
55144 swig_module.cast_initial = swig_cast_initial;
55145
55146 /* Try and load any already created modules */
55147 module_head = SWIG_GetModule(clientdata);
55148 if (module_head) {
55149 swig_module.next = module_head->next;
55150 module_head->next = &swig_module;
55151 } else {
55152 /* This is the first module loaded */
55153 swig_module.next = &swig_module;
55154 SWIG_SetModule(clientdata, &swig_module);
55155 }
55156
55157 /* Now work on filling in swig_module.types */
55158 #ifdef SWIGRUNTIME_DEBUG
55159 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55160 #endif
55161 for (i = 0; i < swig_module.size; ++i) {
55162 swig_type_info *type = 0;
55163 swig_type_info *ret;
55164 swig_cast_info *cast;
55165
55166 #ifdef SWIGRUNTIME_DEBUG
55167 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55168 #endif
55169
55170 /* if there is another module already loaded */
55171 if (swig_module.next != &swig_module) {
55172 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55173 }
55174 if (type) {
55175 /* Overwrite clientdata field */
55176 #ifdef SWIGRUNTIME_DEBUG
55177 printf("SWIG_InitializeModule: found type %s\n", type->name);
55178 #endif
55179 if (swig_module.type_initial[i]->clientdata) {
55180 type->clientdata = swig_module.type_initial[i]->clientdata;
55181 #ifdef SWIGRUNTIME_DEBUG
55182 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55183 #endif
55184 }
55185 } else {
55186 type = swig_module.type_initial[i];
55187 }
55188
55189 /* Insert casting types */
55190 cast = swig_module.cast_initial[i];
55191 while (cast->type) {
55192 /* Don't need to add information already in the list */
55193 ret = 0;
55194 #ifdef SWIGRUNTIME_DEBUG
55195 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55196 #endif
55197 if (swig_module.next != &swig_module) {
55198 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55199 #ifdef SWIGRUNTIME_DEBUG
55200 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55201 #endif
55202 }
55203 if (ret) {
55204 if (type == swig_module.type_initial[i]) {
55205 #ifdef SWIGRUNTIME_DEBUG
55206 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55207 #endif
55208 cast->type = ret;
55209 ret = 0;
55210 } else {
55211 /* Check for casting already in the list */
55212 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55213 #ifdef SWIGRUNTIME_DEBUG
55214 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55215 #endif
55216 if (!ocast) ret = 0;
55217 }
55218 }
55219
55220 if (!ret) {
55221 #ifdef SWIGRUNTIME_DEBUG
55222 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55223 #endif
55224 if (type->cast) {
55225 type->cast->prev = cast;
55226 cast->next = type->cast;
55227 }
55228 type->cast = cast;
55229 }
55230 cast++;
55231 }
55232 /* Set entry in modules->types array equal to the type */
55233 swig_module.types[i] = type;
55234 }
55235 swig_module.types[i] = 0;
55236
55237 #ifdef SWIGRUNTIME_DEBUG
55238 printf("**** SWIG_InitializeModule: Cast List ******\n");
55239 for (i = 0; i < swig_module.size; ++i) {
55240 int j = 0;
55241 swig_cast_info *cast = swig_module.cast_initial[i];
55242 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55243 while (cast->type) {
55244 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55245 cast++;
55246 ++j;
55247 }
55248 printf("---- Total casts: %d\n",j);
55249 }
55250 printf("**** SWIG_InitializeModule: Cast List ******\n");
55251 #endif
55252 }
55253
55254 /* This function will propagate the clientdata field of type to
55255 * any new swig_type_info structures that have been added into the list
55256 * of equivalent types. It is like calling
55257 * SWIG_TypeClientData(type, clientdata) a second time.
55258 */
55259 SWIGRUNTIME void
55260 SWIG_PropagateClientData(void) {
55261 size_t i;
55262 swig_cast_info *equiv;
55263 static int init_run = 0;
55264
55265 if (init_run) return;
55266 init_run = 1;
55267
55268 for (i = 0; i < swig_module.size; i++) {
55269 if (swig_module.types[i]->clientdata) {
55270 equiv = swig_module.types[i]->cast;
55271 while (equiv) {
55272 if (!equiv->converter) {
55273 if (equiv->type && !equiv->type->clientdata)
55274 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55275 }
55276 equiv = equiv->next;
55277 }
55278 }
55279 }
55280 }
55281
55282 #ifdef __cplusplus
55283 #if 0
55284 {
55285 /* c-mode */
55286 #endif
55287 }
55288 #endif
55289
55290
55291
55292 #ifdef __cplusplus
55293 extern "C" {
55294 #endif
55295
55296 /* Python-specific SWIG API */
55297 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55298 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55299 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55300
55301 /* -----------------------------------------------------------------------------
55302 * global variable support code.
55303 * ----------------------------------------------------------------------------- */
55304
55305 typedef struct swig_globalvar {
55306 char *name; /* Name of global variable */
55307 PyObject *(*get_attr)(void); /* Return the current value */
55308 int (*set_attr)(PyObject *); /* Set the value */
55309 struct swig_globalvar *next;
55310 } swig_globalvar;
55311
55312 typedef struct swig_varlinkobject {
55313 PyObject_HEAD
55314 swig_globalvar *vars;
55315 } swig_varlinkobject;
55316
55317 SWIGINTERN PyObject *
55318 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55319 return PyString_FromString("<Swig global variables>");
55320 }
55321
55322 SWIGINTERN PyObject *
55323 swig_varlink_str(swig_varlinkobject *v) {
55324 PyObject *str = PyString_FromString("(");
55325 swig_globalvar *var;
55326 for (var = v->vars; var; var=var->next) {
55327 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55328 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55329 }
55330 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55331 return str;
55332 }
55333
55334 SWIGINTERN int
55335 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55336 PyObject *str = swig_varlink_str(v);
55337 fprintf(fp,"Swig global variables ");
55338 fprintf(fp,"%s\n", PyString_AsString(str));
55339 Py_DECREF(str);
55340 return 0;
55341 }
55342
55343 SWIGINTERN void
55344 swig_varlink_dealloc(swig_varlinkobject *v) {
55345 swig_globalvar *var = v->vars;
55346 while (var) {
55347 swig_globalvar *n = var->next;
55348 free(var->name);
55349 free(var);
55350 var = n;
55351 }
55352 }
55353
55354 SWIGINTERN PyObject *
55355 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55356 PyObject *res = NULL;
55357 swig_globalvar *var = v->vars;
55358 while (var) {
55359 if (strcmp(var->name,n) == 0) {
55360 res = (*var->get_attr)();
55361 break;
55362 }
55363 var = var->next;
55364 }
55365 if (res == NULL && !PyErr_Occurred()) {
55366 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55367 }
55368 return res;
55369 }
55370
55371 SWIGINTERN int
55372 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55373 int res = 1;
55374 swig_globalvar *var = v->vars;
55375 while (var) {
55376 if (strcmp(var->name,n) == 0) {
55377 res = (*var->set_attr)(p);
55378 break;
55379 }
55380 var = var->next;
55381 }
55382 if (res == 1 && !PyErr_Occurred()) {
55383 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55384 }
55385 return res;
55386 }
55387
55388 SWIGINTERN PyTypeObject*
55389 swig_varlink_type(void) {
55390 static char varlink__doc__[] = "Swig var link object";
55391 static PyTypeObject varlink_type;
55392 static int type_init = 0;
55393 if (!type_init) {
55394 const PyTypeObject tmp
55395 = {
55396 PyObject_HEAD_INIT(NULL)
55397 0, /* Number of items in variable part (ob_size) */
55398 (char *)"swigvarlink", /* Type name (tp_name) */
55399 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55400 0, /* Itemsize (tp_itemsize) */
55401 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55402 (printfunc) swig_varlink_print, /* Print (tp_print) */
55403 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55404 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55405 0, /* tp_compare */
55406 (reprfunc) swig_varlink_repr, /* tp_repr */
55407 0, /* tp_as_number */
55408 0, /* tp_as_sequence */
55409 0, /* tp_as_mapping */
55410 0, /* tp_hash */
55411 0, /* tp_call */
55412 (reprfunc)swig_varlink_str, /* tp_str */
55413 0, /* tp_getattro */
55414 0, /* tp_setattro */
55415 0, /* tp_as_buffer */
55416 0, /* tp_flags */
55417 varlink__doc__, /* tp_doc */
55418 0, /* tp_traverse */
55419 0, /* tp_clear */
55420 0, /* tp_richcompare */
55421 0, /* tp_weaklistoffset */
55422 #if PY_VERSION_HEX >= 0x02020000
55423 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55424 #endif
55425 #if PY_VERSION_HEX >= 0x02030000
55426 0, /* tp_del */
55427 #endif
55428 #ifdef COUNT_ALLOCS
55429 0,0,0,0 /* tp_alloc -> tp_next */
55430 #endif
55431 };
55432 varlink_type = tmp;
55433 varlink_type.ob_type = &PyType_Type;
55434 type_init = 1;
55435 }
55436 return &varlink_type;
55437 }
55438
55439 /* Create a variable linking object for use later */
55440 SWIGINTERN PyObject *
55441 SWIG_Python_newvarlink(void) {
55442 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55443 if (result) {
55444 result->vars = 0;
55445 }
55446 return ((PyObject*) result);
55447 }
55448
55449 SWIGINTERN void
55450 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55451 swig_varlinkobject *v = (swig_varlinkobject *) p;
55452 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55453 if (gv) {
55454 size_t size = strlen(name)+1;
55455 gv->name = (char *)malloc(size);
55456 if (gv->name) {
55457 strncpy(gv->name,name,size);
55458 gv->get_attr = get_attr;
55459 gv->set_attr = set_attr;
55460 gv->next = v->vars;
55461 }
55462 }
55463 v->vars = gv;
55464 }
55465
55466 SWIGINTERN PyObject *
55467 SWIG_globals() {
55468 static PyObject *_SWIG_globals = 0;
55469 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55470 return _SWIG_globals;
55471 }
55472
55473 /* -----------------------------------------------------------------------------
55474 * constants/methods manipulation
55475 * ----------------------------------------------------------------------------- */
55476
55477 /* Install Constants */
55478 SWIGINTERN void
55479 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55480 PyObject *obj = 0;
55481 size_t i;
55482 for (i = 0; constants[i].type; ++i) {
55483 switch(constants[i].type) {
55484 case SWIG_PY_POINTER:
55485 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55486 break;
55487 case SWIG_PY_BINARY:
55488 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55489 break;
55490 default:
55491 obj = 0;
55492 break;
55493 }
55494 if (obj) {
55495 PyDict_SetItemString(d, constants[i].name, obj);
55496 Py_DECREF(obj);
55497 }
55498 }
55499 }
55500
55501 /* -----------------------------------------------------------------------------*/
55502 /* Fix SwigMethods to carry the callback ptrs when needed */
55503 /* -----------------------------------------------------------------------------*/
55504
55505 SWIGINTERN void
55506 SWIG_Python_FixMethods(PyMethodDef *methods,
55507 swig_const_info *const_table,
55508 swig_type_info **types,
55509 swig_type_info **types_initial) {
55510 size_t i;
55511 for (i = 0; methods[i].ml_name; ++i) {
55512 char *c = methods[i].ml_doc;
55513 if (c && (c = strstr(c, "swig_ptr: "))) {
55514 int j;
55515 swig_const_info *ci = 0;
55516 char *name = c + 10;
55517 for (j = 0; const_table[j].type; ++j) {
55518 if (strncmp(const_table[j].name, name,
55519 strlen(const_table[j].name)) == 0) {
55520 ci = &(const_table[j]);
55521 break;
55522 }
55523 }
55524 if (ci) {
55525 size_t shift = (ci->ptype) - types;
55526 swig_type_info *ty = types_initial[shift];
55527 size_t ldoc = (c - methods[i].ml_doc);
55528 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55529 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55530 if (ndoc) {
55531 char *buff = ndoc;
55532 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55533 if (ptr) {
55534 strncpy(buff, methods[i].ml_doc, ldoc);
55535 buff += ldoc;
55536 strncpy(buff, "swig_ptr: ", 10);
55537 buff += 10;
55538 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55539 methods[i].ml_doc = ndoc;
55540 }
55541 }
55542 }
55543 }
55544 }
55545 }
55546
55547 #ifdef __cplusplus
55548 }
55549 #endif
55550
55551 /* -----------------------------------------------------------------------------*
55552 * Partial Init method
55553 * -----------------------------------------------------------------------------*/
55554
55555 #ifdef __cplusplus
55556 extern "C"
55557 #endif
55558 SWIGEXPORT void SWIG_init(void) {
55559 PyObject *m, *d;
55560
55561 /* Fix SwigMethods to carry the callback ptrs when needed */
55562 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55563
55564 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55565 d = PyModule_GetDict(m);
55566
55567 SWIG_InitializeModule(0);
55568 SWIG_InstallConstants(d,swig_const_table);
55569
55570
55571
55572 #ifndef wxPyUSE_EXPORT
55573 // Make our API structure a CObject so other modules can import it
55574 // from this module.
55575 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55576 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55577 Py_XDECREF(cobj);
55578 #endif
55579
55580 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55581 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55582 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55583 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55584 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55585 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55586 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55587 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55588 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55589 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55590 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55591 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55592 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55593 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55594 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55595 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55596 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55597 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55598 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55599 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55600 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55601 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55602 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55603 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55604 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55605 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55606 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55607 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55608 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55609 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55610 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55611 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55612 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55613 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55614 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55615 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55616 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55617 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55618 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55619 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55620 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55621 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55622 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55623 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55624 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55625 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55626 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55627 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55628 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55629 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55630 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55631 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55632 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55633 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55634 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55635 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55636 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55637 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55638 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55639 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55640 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55641 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55642 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55643 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55644 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55645 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55646 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55647 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55648 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55649 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55650 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55651 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55652 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55653 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55654 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55655 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55656 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55657 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55658 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55659 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55660 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55661 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55662 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55663 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55664 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55665 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55666 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55667 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55668 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55669 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55670 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55671 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55672 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55673 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55674 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55675 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55676 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55677 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55678 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55679 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55680 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55681 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55682 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55683 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55684 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55685 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55686 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55687 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55688 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55689 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55690 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55691 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55692 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55693 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55694 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55695 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55696 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55697 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55698 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55699 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55700 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55701 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55702 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55703 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55704 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55705 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55706 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55707 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55708 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55709 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55710 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55711 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55712 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55713 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55714 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55715 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55716 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55717 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55718 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55719 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55720 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55721 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55722 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55723 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55724 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55725 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55726 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55727 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55728 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55729 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55730 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55731 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55732 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55733 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55734 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55735 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55736 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55737 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55738 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55739 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55740 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55741 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55742 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55743 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55744 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55745 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55746 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55747 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55748 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55749 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55750 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55751 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55752 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55753 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55754 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55755 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55756 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55757 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55758 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55759 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55760 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55761 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55762 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55763 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55764 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55765 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55766 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55767 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55768 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55769 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55770 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55771 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55772 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55773 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55774 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55775 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55776 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55777 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55778 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55779 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55780 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55781 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55782 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55783 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55784 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55785 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55786 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55787 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55788 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55789 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55790 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55791 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55792 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55793 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55794 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55795 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55796 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55797 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55798 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55799 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55800 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55801 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55802 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55803 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55804 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55805 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55806 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55807 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55808 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55809 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55810 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55811 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55812 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55813 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55814 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55815 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55816 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55817 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55818 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55819 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55820 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55821 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55822 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55823 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55824 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55825 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55826 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55827 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55828 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55829 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55830 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55831 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55832 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55833 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55834 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55835 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55836 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55837 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55838 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55839 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55840 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55841 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55842 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55843 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55844 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55845 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55846 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55847 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55848 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55849 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55850 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55851 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55852 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55853 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55854 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55855 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55856 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55857 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55858 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55859 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55860 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55861 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55862 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55863 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55864 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55865 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55866 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55867 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55868 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55869 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55870 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55871 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55872 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55873 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55874 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55875 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55876 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55877 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55878 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55879 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55880 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55881 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55882 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55883 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55884 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55885 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55886 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55887 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55888 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55889 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55890 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55891 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55892 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55893 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55894 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55895 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55896 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55897 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55898 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55899 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55900 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55901 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55902 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55903 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55904 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55905 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55906 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55907 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55908 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55909 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55910 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55911 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55912 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55913 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55914 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55915 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55916 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55917 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55918 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55919 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55920 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55921 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55922 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55923 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55924 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55925 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55926 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55927 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55928 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55929 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55930 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55931 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55932 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55933 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55934 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55935 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55936 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55937 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55938 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55939 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55940 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55941 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55942 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55943 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55944 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55945 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55946 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55947 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55948 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55949 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55950 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55951 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55952 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55953 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55954 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55955 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55956 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55957 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55958 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55959 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55960 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55961 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55962 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55963 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55964 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55965 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55966 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55967 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55968 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55969 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55970 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55971 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55972 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55973 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55974 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55975 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55976 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55977 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55978 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55979 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55980 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55981 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55982 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55983 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55984 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55985 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55986 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55987 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55988 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55989 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55990 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55991 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55992 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55993 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55994 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55995 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55996 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55997 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55998 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55999 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56000 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56001 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56002 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56003 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56004 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56005 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56006 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56007 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56008 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56009 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56010 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56011 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56012 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56013 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56014 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56015 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56016 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56017 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56018 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56019 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56020 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56021 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56022 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56023 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56024 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56025 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56026 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56027 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56028 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56029 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56030 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56031 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56032 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56033 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56034 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56035 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56036 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56037 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56038 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56039 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56040 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56041 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56042 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56043 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56044 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56045 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56046 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56047 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56048 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56049 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56050 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56051 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56052 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56053 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56054 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56055 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56056 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56057 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56058 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56059 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56060 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56061 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56062 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56063 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56064 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56065 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56066 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56067 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56068 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56069 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56070 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56071 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56072 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56073 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56074 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56075 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56076 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56077 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56078 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56079 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56080 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56081 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56082 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56083 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56084 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56085 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56086 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56087 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56088 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56089 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56090 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56091 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56092 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56093 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56094 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56095 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56096 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56097 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56098 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56099 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56100 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56101 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56102 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56103 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56104 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56105 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56106 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56107 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56108 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56109 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56110 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56111 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56112 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56113 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56114 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56115 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56116 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56117 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56118 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56119 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56120 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56121 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56122 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56123 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56124 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56125 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56126 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56127 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56128 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56129 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56130 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56131 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56132 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56133 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56134 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56135 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56136 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56137 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56138 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56139 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56140 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56141 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56142 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56143 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56144 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56145 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56146 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56147 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56148 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56149 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56150 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56151 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56152 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56153 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56154 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56155 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56156 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56157 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56158 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56159 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56160 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56161 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56162 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56163 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56164 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56165 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56166 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56167 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56168 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56169 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56170 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56171 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56172 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56173 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56174 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56175 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56176 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56177 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56178 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56179 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56180 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56181 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56182 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56183 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56184 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56185 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56186 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56187 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56188 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56189 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56190 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56191 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56192 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56193 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56194 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56195 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56196 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56197 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56198 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56199 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56200 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56201 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56202 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56203 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56204 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56205 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56206 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56207 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56208 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56209 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56210 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56211 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56212 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56213 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56214 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56215 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56216 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56217 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56218 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56219 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56220 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56221 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56222 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56223 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56224 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56225 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56226 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56227 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56228 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56229 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56230 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56231 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56232 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56233 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56234 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56235 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56236 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56237 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56238 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56239 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56240 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56241 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56242
56243 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56244
56245
56246 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56247
56248 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56249 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56250 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56251 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56252 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56253 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56254 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56255 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56256 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56257 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56258 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56259 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56260 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56261 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56262 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56263 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56264 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56265 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56266 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56267 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56268 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56269 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56270 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56271 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56272 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56273 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56274 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56275 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56276 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56277 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56278 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56279 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56280 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56281 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56282 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56283 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56284 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56285 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56286 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56287 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56288 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56289 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56290 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56291 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56292 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56293 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56294 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56295 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56296 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56297 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56298 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56299 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56300 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56301 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56302 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56303 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56304 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56305 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56306 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56307 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56308 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56309 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56310 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56311 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56312 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56313 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56314 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56315 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56316 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56317 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56318 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56319 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56320 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56321 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56322 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56323 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56324 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56325 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56326 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56327 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56328 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56329 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56330 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56331 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56332 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56333 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56334 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56335 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56336 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56337 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56338 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56339 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56340 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56341 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56342 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56343 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56344 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56345 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56346 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56347 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56348 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56349 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56350 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56351 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56352 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56353 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56354 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56355 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56356 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56357 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56358 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56359 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56360 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56361 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56362 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56363 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56364 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56365 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56366 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56367 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56368 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56369 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56370 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56371 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56372 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56373 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56374 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56375 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56376 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56377 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56378 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56379 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56380 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56381 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56382 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56383 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56384 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56385 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56386 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56387 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56388 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56389 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56390 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56391 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56392 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56393 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56394 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56395 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56396 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56397 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56398 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56399 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56400 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56401 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56402 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56403 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56404 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56405 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56406 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56407 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56408 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56409 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56410 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56411 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56412 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56413 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56414 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56415 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56416 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56417 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56418 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56419 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56420 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56421 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56422 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56423 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56424 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56425 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56426 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56427 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56428 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56429 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56430 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56431 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56432 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56433 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56434 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56435 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56436 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56437 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56438 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56439 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56440 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56441 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56442 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56443 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56444 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56445 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56446 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56447 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56448 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56449 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56450 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56451 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56452 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56453 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56454
56455 // Initialize threading, some globals and such
56456 __wxPyPreStart(d);
56457
56458
56459 // Although these are defined in __version__ they need to be here too so
56460 // that an assert can be done to ensure that the wxPython and the wxWindows
56461 // versions match.
56462 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56463 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56464 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56465
56466 }
56467