]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added Bryan's new icons
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutDirection swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRegion swig_types[110]
2577 #define SWIGTYPE_p_wxScrollEvent swig_types[111]
2578 #define SWIGTYPE_p_wxScrollWinEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSetCursorEvent swig_types[113]
2580 #define SWIGTYPE_p_wxShowEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSize swig_types[115]
2582 #define SWIGTYPE_p_wxSizeEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSizer swig_types[117]
2584 #define SWIGTYPE_p_wxSizerItem swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBox swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[121]
2588 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[122]
2589 #define SWIGTYPE_p_wxTIFFHandler swig_types[123]
2590 #define SWIGTYPE_p_wxToolTip swig_types[124]
2591 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[125]
2592 #define SWIGTYPE_p_wxValidator swig_types[126]
2593 #define SWIGTYPE_p_wxVisualAttributes swig_types[127]
2594 #define SWIGTYPE_p_wxWindow swig_types[128]
2595 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[129]
2596 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[130]
2597 #define SWIGTYPE_p_wxXPMHandler swig_types[131]
2598 #define SWIGTYPE_p_wxZipFSHandler swig_types[132]
2599 static swig_type_info *swig_types[134];
2600 static swig_module_info swig_module = {swig_types, 133, 0, 0, 0, 0};
2601 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2602 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2603
2604 /* -------- TYPES TABLE (END) -------- */
2605
2606 #if (PY_VERSION_HEX <= 0x02000000)
2607 # if !defined(SWIG_PYTHON_CLASSIC)
2608 # error "This python version requires to use swig with the '-classic' option"
2609 # endif
2610 #endif
2611 #if (PY_VERSION_HEX <= 0x02020000)
2612 # error "This python version requires to use swig with the '-nomodern' option"
2613 #endif
2614 #if (PY_VERSION_HEX <= 0x02020000)
2615 # error "This python version requires to use swig with the '-nomodernargs' option"
2616 #endif
2617 #ifndef METH_O
2618 # error "This python version requires to use swig with the '-nofastunpack' option"
2619 #endif
2620
2621 /*-----------------------------------------------
2622 @(target):= _core_.so
2623 ------------------------------------------------*/
2624 #define SWIG_init init_core_
2625
2626 #define SWIG_name "_core_"
2627
2628 #define SWIGVERSION 0x010329
2629
2630
2631 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2632 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2633
2634
2635 #include <stdexcept>
2636
2637
2638 namespace swig {
2639 class PyObject_ptr {
2640 protected:
2641 PyObject *_obj;
2642
2643 public:
2644 PyObject_ptr() :_obj(0)
2645 {
2646 }
2647
2648 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2649 {
2650 Py_XINCREF(_obj);
2651 }
2652
2653 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2654 {
2655 if (initial_ref) Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr & operator=(const PyObject_ptr& item)
2659 {
2660 Py_XINCREF(item._obj);
2661 Py_XDECREF(_obj);
2662 _obj = item._obj;
2663 return *this;
2664 }
2665
2666 ~PyObject_ptr()
2667 {
2668 Py_XDECREF(_obj);
2669 }
2670
2671 operator PyObject *() const
2672 {
2673 return _obj;
2674 }
2675
2676 PyObject *operator->() const
2677 {
2678 return _obj;
2679 }
2680 };
2681 }
2682
2683
2684 namespace swig {
2685 struct PyObject_var : PyObject_ptr {
2686 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2687
2688 PyObject_var & operator = (PyObject* obj)
2689 {
2690 Py_XDECREF(_obj);
2691 _obj = obj;
2692 return *this;
2693 }
2694 };
2695 }
2696
2697
2698 #include "wx/wxPython/wxPython_int.h"
2699 #include "wx/wxPython/pyclasses.h"
2700 #include "wx/wxPython/twoitem.h"
2701
2702
2703 #ifndef wxPyUSE_EXPORT
2704 // Helper functions for dealing with SWIG objects and such. These are
2705 // located here so they know about the SWIG types and functions declared
2706 // in the wrapper code.
2707
2708 #include <wx/hashmap.h>
2709 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2710
2711
2712 // Maintains a hashmap of className to swig_type_info pointers. Given the
2713 // name of a class either looks up the type info in the cache, or scans the
2714 // SWIG tables for it.
2715 extern PyObject* wxPyPtrTypeMap;
2716 static
2717 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2718
2719 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2720
2721 if (typeInfoCache == NULL)
2722 typeInfoCache = new wxPyTypeInfoHashMap;
2723
2724 wxString name(className);
2725 swig_type_info* swigType = (*typeInfoCache)[name];
2726
2727 if (! swigType) {
2728 // it wasn't in the cache, so look it up from SWIG
2729 name.Append(wxT(" *"));
2730 swigType = SWIG_TypeQuery(name.mb_str());
2731
2732 // if it still wasn't found, try looking for a mapped name
2733 if (!swigType) {
2734 PyObject* item;
2735 name = className;
2736
2737 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2738 (char*)(const char*)name.mbc_str())) != NULL) {
2739 name = wxString(PyString_AsString(item), *wxConvCurrent);
2740 name.Append(wxT(" *"));
2741 swigType = SWIG_TypeQuery(name.mb_str());
2742 }
2743 }
2744 if (swigType) {
2745 // and add it to the map if found
2746 (*typeInfoCache)[className] = swigType;
2747 }
2748 }
2749 return swigType;
2750 }
2751
2752
2753 // Check if a class name is a type known to SWIG
2754 bool wxPyCheckSwigType(const wxChar* className) {
2755
2756 swig_type_info* swigType = wxPyFindSwigType(className);
2757 return swigType != NULL;
2758 }
2759
2760
2761 // Given a pointer to a C++ object and a class name, construct a Python proxy
2762 // object for it.
2763 PyObject* wxPyConstructObject(void* ptr,
2764 const wxChar* className,
2765 int setThisOwn) {
2766
2767 swig_type_info* swigType = wxPyFindSwigType(className);
2768 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2769
2770 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2771 }
2772
2773
2774 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2775 // Ensures that the proxy object is of the specified (or derived) type. If
2776 // not able to perform the conversion then a Python exception is set and the
2777 // error should be handled properly in the caller. Returns True on success.
2778 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2779 const wxChar* className) {
2780
2781 swig_type_info* swigType = wxPyFindSwigType(className);
2782 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2783
2784 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2785 }
2786
2787
2788
2789 // Make a SWIGified pointer object suitable for a .this attribute
2790 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2791
2792 PyObject* robj = NULL;
2793
2794 swig_type_info* swigType = wxPyFindSwigType(className);
2795 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2796
2797 robj = PySwigObject_New(ptr, swigType, 0);
2798 return robj;
2799 }
2800
2801
2802 // Python's PyInstance_Check does not return True for instances of new-style
2803 // classes. This should get close enough for both new and old classes but I
2804 // should re-evaluate the need for doing instance checks...
2805 bool wxPyInstance_Check(PyObject* obj) {
2806 return PyObject_HasAttrString(obj, "__class__") != 0;
2807 }
2808
2809
2810 // This one checks if the object is an instance of a SWIG proxy class (it has
2811 // a .this attribute, and the .this attribute is a PySwigObject.)
2812 bool wxPySwigInstance_Check(PyObject* obj) {
2813 static PyObject* this_str = NULL;
2814 if (this_str == NULL)
2815 this_str = PyString_FromString("this");
2816
2817 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2818 if (this_attr) {
2819 bool retval = (PySwigObject_Check(this_attr) != 0);
2820 Py_DECREF(this_attr);
2821 return retval;
2822 }
2823
2824 PyErr_Clear();
2825 return false;
2826 }
2827
2828
2829 // Export a C API in a struct. Other modules will be able to load this from
2830 // the wx._core_ module and will then have safe access to these functions,
2831 // even if they are located in another shared library.
2832 static wxPyCoreAPI API = {
2833
2834 wxPyCheckSwigType,
2835 wxPyConstructObject,
2836 wxPyConvertSwigPtr,
2837 wxPyMakeSwigPtr,
2838
2839 wxPyBeginAllowThreads,
2840 wxPyEndAllowThreads,
2841 wxPyBeginBlockThreads,
2842 wxPyEndBlockThreads,
2843
2844 wxPy_ConvertList,
2845
2846 wxString_in_helper,
2847 Py2wxString,
2848 wx2PyString,
2849
2850 byte_LIST_helper,
2851 int_LIST_helper,
2852 long_LIST_helper,
2853 string_LIST_helper,
2854 wxPoint_LIST_helper,
2855 wxBitmap_LIST_helper,
2856 wxString_LIST_helper,
2857 wxAcceleratorEntry_LIST_helper,
2858
2859 wxSize_helper,
2860 wxPoint_helper,
2861 wxRealPoint_helper,
2862 wxRect_helper,
2863 wxColour_helper,
2864 wxPoint2D_helper,
2865
2866 wxPySimple_typecheck,
2867 wxColour_typecheck,
2868
2869 wxPyCBH_setCallbackInfo,
2870 wxPyCBH_findCallback,
2871 wxPyCBH_callCallback,
2872 wxPyCBH_callCallbackObj,
2873 wxPyCBH_delete,
2874
2875 wxPyMake_wxObject,
2876 wxPyMake_wxSizer,
2877 wxPyPtrTypeMap_Add,
2878 wxPy2int_seq_helper,
2879 wxPy4int_seq_helper,
2880 wxArrayString2PyList_helper,
2881 wxArrayInt2PyList_helper,
2882
2883 wxPyClientData_dtor,
2884 wxPyUserData_dtor,
2885 wxPyOORClientData_dtor,
2886
2887 wxPyCBInputStream_create,
2888 wxPyCBInputStream_copy,
2889
2890 wxPyInstance_Check,
2891 wxPySwigInstance_Check,
2892
2893 wxPyCheckForApp
2894
2895 };
2896
2897 #endif
2898
2899
2900 #if !WXWIN_COMPATIBILITY_2_4
2901 #define wxHIDE_READONLY 0
2902 #endif
2903
2904
2905 #define SWIG_From_long PyInt_FromLong
2906
2907
2908 SWIGINTERNINLINE PyObject *
2909 SWIG_From_int (int value)
2910 {
2911 return SWIG_From_long (value);
2912 }
2913
2914 static const wxString wxPyEmptyString(wxEmptyString);
2915 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2916 return self->GetClassInfo()->GetClassName();
2917 }
2918 SWIGINTERN void wxObject_Destroy(wxObject *self){
2919 delete self;
2920 }
2921
2922 #ifndef __WXMAC__
2923 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2924 #endif
2925
2926
2927 #include <limits.h>
2928 #ifndef LLONG_MIN
2929 # define LLONG_MIN LONG_LONG_MIN
2930 #endif
2931 #ifndef LLONG_MAX
2932 # define LLONG_MAX LONG_LONG_MAX
2933 #endif
2934 #ifndef ULLONG_MAX
2935 # define ULLONG_MAX ULONG_LONG_MAX
2936 #endif
2937
2938
2939 SWIGINTERN int
2940 SWIG_AsVal_long (PyObject* obj, long* val)
2941 {
2942 if (PyNumber_Check(obj)) {
2943 if (val) *val = PyInt_AsLong(obj);
2944 return SWIG_OK;
2945 }
2946 return SWIG_TypeError;
2947 }
2948
2949
2950 SWIGINTERN int
2951 SWIG_AsVal_int (PyObject * obj, int *val)
2952 {
2953 long v;
2954 int res = SWIG_AsVal_long (obj, &v);
2955 if (SWIG_IsOK(res)) {
2956 if ((v < INT_MIN || v > INT_MAX)) {
2957 return SWIG_OverflowError;
2958 } else {
2959 if (val) *val = static_cast< int >(v);
2960 }
2961 }
2962 return res;
2963 }
2964
2965 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return false;
2968 if ( ! wxSize_helper(other, &obj) ) {
2969 PyErr_Clear();
2970 return false;
2971 }
2972 return self->operator==(*obj);
2973 }
2974 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2975 wxSize temp, *obj = &temp;
2976 if ( other == Py_None ) return true;
2977 if ( ! wxSize_helper(other, &obj)) {
2978 PyErr_Clear();
2979 return true;
2980 }
2981 return self->operator!=(*obj);
2982 }
2983
2984 #include <float.h>
2985
2986
2987 SWIGINTERN int
2988 SWIG_AsVal_double (PyObject *obj, double* val)
2989 {
2990 if (PyNumber_Check(obj)) {
2991 if (val) *val = PyFloat_AsDouble(obj);
2992 return SWIG_OK;
2993 }
2994 return SWIG_TypeError;
2995 }
2996
2997
2998 SWIGINTERN int
2999 SWIG_AsVal_float (PyObject * obj, float *val)
3000 {
3001 double v;
3002 int res = SWIG_AsVal_double (obj, &v);
3003 if (SWIG_IsOK(res)) {
3004 if ((v < -FLT_MAX || v > FLT_MAX)) {
3005 return SWIG_OverflowError;
3006 } else {
3007 if (val) *val = static_cast< float >(v);
3008 }
3009 }
3010 return res;
3011 }
3012
3013 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3014 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3015 PyObject* tup = PyTuple_New(2);
3016 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3017 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3018 wxPyEndBlockThreads(blocked);
3019 return tup;
3020 }
3021
3022 #define SWIG_From_double PyFloat_FromDouble
3023
3024 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3025 wxRealPoint temp, *obj = &temp;
3026 if ( other == Py_None ) return false;
3027 if ( ! wxRealPoint_helper(other, &obj) ) {
3028 PyErr_Clear();
3029 return false;
3030 }
3031 return self->operator==(*obj);
3032 }
3033 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3034 wxRealPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return true;
3036 if ( ! wxRealPoint_helper(other, &obj)) {
3037 PyErr_Clear();
3038 return true;
3039 }
3040 return self->operator!=(*obj);
3041 }
3042 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3043 self->x = x;
3044 self->y = y;
3045 }
3046 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3047 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3048 PyObject* tup = PyTuple_New(2);
3049 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3050 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3051 wxPyEndBlockThreads(blocked);
3052 return tup;
3053 }
3054 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3055 wxPoint temp, *obj = &temp;
3056 if ( other == Py_None ) return false;
3057 if ( ! wxPoint_helper(other, &obj) ) {
3058 PyErr_Clear();
3059 return false;
3060 }
3061 return self->operator==(*obj);
3062 }
3063 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3064 wxPoint temp, *obj = &temp;
3065 if ( other == Py_None ) return true;
3066 if ( ! wxPoint_helper(other, &obj)) {
3067 PyErr_Clear();
3068 return true;
3069 }
3070 return self->operator!=(*obj);
3071 }
3072 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3073 self->x = x;
3074 self->y = y;
3075 }
3076 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 PyObject* tup = PyTuple_New(2);
3079 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3080 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3081 wxPyEndBlockThreads(blocked);
3082 return tup;
3083 }
3084 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3085 wxRect temp, *obj = &temp;
3086 if ( other == Py_None ) return false;
3087 if ( ! wxRect_helper(other, &obj) ) {
3088 PyErr_Clear();
3089 return false;
3090 }
3091 return self->operator==(*obj);
3092 }
3093 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3094 wxRect temp, *obj = &temp;
3095 if ( other == Py_None ) return true;
3096 if ( ! wxRect_helper(other, &obj)) {
3097 PyErr_Clear();
3098 return true;
3099 }
3100 return self->operator!=(*obj);
3101 }
3102 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3103 self->x = x;
3104 self->y = y;
3105 self->width = width;
3106 self->height = height;
3107 }
3108 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3109 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3110 PyObject* tup = PyTuple_New(4);
3111 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3112 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3113 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3114 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3115 wxPyEndBlockThreads(blocked);
3116 return tup;
3117 }
3118
3119 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3120 wxRegion reg1(*r1);
3121 wxRegion reg2(*r2);
3122 wxRect dest(0,0,0,0);
3123 PyObject* obj;
3124
3125 reg1.Intersect(reg2);
3126 dest = reg1.GetBox();
3127
3128 if (dest != wxRect(0,0,0,0)) {
3129 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3130 wxRect* newRect = new wxRect(dest);
3131 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3132 wxPyEndBlockThreads(blocked);
3133 return obj;
3134 }
3135 Py_INCREF(Py_None);
3136 return Py_None;
3137 }
3138
3139 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3140 wxPoint2D temp, *obj = &temp;
3141 if ( other == Py_None ) return false;
3142 if ( ! wxPoint2D_helper(other, &obj) ) {
3143 PyErr_Clear();
3144 return false;
3145 }
3146 return self->operator==(*obj);
3147 }
3148 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3149 wxPoint2D temp, *obj = &temp;
3150 if ( other == Py_None ) return true;
3151 if ( ! wxPoint2D_helper(other, &obj)) {
3152 PyErr_Clear();
3153 return true;
3154 }
3155 return self->operator!=(*obj);
3156 }
3157 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3158 self->m_x = x;
3159 self->m_y = y;
3160 }
3161 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3162 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3163 PyObject* tup = PyTuple_New(2);
3164 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3165 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3166 wxPyEndBlockThreads(blocked);
3167 return tup;
3168 }
3169
3170 #include "wx/wxPython/pyistream.h"
3171
3172 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3173 wxInputStream* wxis = wxPyCBInputStream::create(p);
3174 if (wxis)
3175 return new wxPyInputStream(wxis);
3176 else
3177 return NULL;
3178 }
3179
3180 SWIGINTERN swig_type_info*
3181 SWIG_pchar_descriptor()
3182 {
3183 static int init = 0;
3184 static swig_type_info* info = 0;
3185 if (!init) {
3186 info = SWIG_TypeQuery("_p_char");
3187 init = 1;
3188 }
3189 return info;
3190 }
3191
3192
3193 SWIGINTERNINLINE PyObject *
3194 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3195 {
3196 if (carray) {
3197 if (size > INT_MAX) {
3198 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3199 return pchar_descriptor ?
3200 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3201 } else {
3202 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3203 }
3204 } else {
3205 return SWIG_Py_Void();
3206 }
3207 }
3208
3209
3210 SWIGINTERNINLINE PyObject *
3211 SWIG_From_char (char c)
3212 {
3213 return SWIG_FromCharPtrAndSize(&c,1);
3214 }
3215
3216
3217 SWIGINTERNINLINE PyObject*
3218 SWIG_From_unsigned_SS_long (unsigned long value)
3219 {
3220 return (value > LONG_MAX) ?
3221 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3222 }
3223
3224
3225 SWIGINTERNINLINE PyObject *
3226 SWIG_From_size_t (size_t value)
3227 {
3228 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3229 }
3230
3231
3232 SWIGINTERN int
3233 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3234 {
3235 if (PyString_Check(obj)) {
3236 char *cstr; Py_ssize_t len;
3237 PyString_AsStringAndSize(obj, &cstr, &len);
3238 if (cptr) {
3239 if (alloc) {
3240 /*
3241 In python the user should not be able to modify the inner
3242 string representation. To warranty that, if you define
3243 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3244 buffer is always returned.
3245
3246 The default behavior is just to return the pointer value,
3247 so, be careful.
3248 */
3249 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3250 if (*alloc != SWIG_OLDOBJ)
3251 #else
3252 if (*alloc == SWIG_NEWOBJ)
3253 #endif
3254 {
3255 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3256 *alloc = SWIG_NEWOBJ;
3257 }
3258 else {
3259 *cptr = cstr;
3260 *alloc = SWIG_OLDOBJ;
3261 }
3262 } else {
3263 *cptr = PyString_AsString(obj);
3264 }
3265 }
3266 if (psize) *psize = len + 1;
3267 return SWIG_OK;
3268 } else {
3269 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3270 if (pchar_descriptor) {
3271 void* vptr = 0;
3272 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3273 if (cptr) *cptr = (char *) vptr;
3274 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3275 if (alloc) *alloc = SWIG_OLDOBJ;
3276 return SWIG_OK;
3277 }
3278 }
3279 }
3280 return SWIG_TypeError;
3281 }
3282
3283
3284 SWIGINTERN int
3285 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3286 {
3287 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3288 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3289 if (SWIG_IsOK(res)) {
3290 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3291 if (csize <= size) {
3292 if (val) {
3293 if (csize) memcpy(val, cptr, csize*sizeof(char));
3294 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3295 }
3296 if (alloc == SWIG_NEWOBJ) {
3297 delete[] cptr;
3298 res = SWIG_DelNewMask(res);
3299 }
3300 return res;
3301 }
3302 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3303 }
3304 return SWIG_TypeError;
3305 }
3306
3307
3308 SWIGINTERN int
3309 SWIG_AsVal_char (PyObject * obj, char *val)
3310 {
3311 int res = SWIG_AsCharArray(obj, val, 1);
3312 if (!SWIG_IsOK(res)) {
3313 long v;
3314 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3315 if (SWIG_IsOK(res)) {
3316 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3317 if (val) *val = static_cast< char >(v);
3318 } else {
3319 res = SWIG_OverflowError;
3320 }
3321 }
3322 }
3323 return res;
3324 }
3325
3326 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3327 // We use only strings for the streams, not unicode
3328 PyObject* str = PyObject_Str(obj);
3329 if (! str) {
3330 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3331 return;
3332 }
3333 self->Write(PyString_AS_STRING(str),
3334 PyString_GET_SIZE(str));
3335 Py_DECREF(str);
3336 }
3337
3338 #include "wx/wxPython/pyistream.h"
3339
3340
3341 class wxPyFileSystemHandler : public wxFileSystemHandler
3342 {
3343 public:
3344 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3345
3346 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3347 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3348 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3349 DEC_PYCALLBACK_STRING__pure(FindNext);
3350
3351 wxString GetProtocol(const wxString& location) {
3352 return wxFileSystemHandler::GetProtocol(location);
3353 }
3354
3355 wxString GetLeftLocation(const wxString& location) {
3356 return wxFileSystemHandler::GetLeftLocation(location);
3357 }
3358
3359 wxString GetAnchor(const wxString& location) {
3360 return wxFileSystemHandler::GetAnchor(location);
3361 }
3362
3363 wxString GetRightLocation(const wxString& location) {
3364 return wxFileSystemHandler::GetRightLocation(location);
3365 }
3366
3367 wxString GetMimeTypeFromExt(const wxString& location) {
3368 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3369 }
3370
3371 PYPRIVATE;
3372 };
3373
3374
3375 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3376 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3377 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3378 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3379
3380
3381 SWIGINTERN int
3382 SWIG_AsVal_bool (PyObject *obj, bool *val)
3383 {
3384 if (obj == Py_True) {
3385 if (val) *val = true;
3386 return SWIG_OK;
3387 } else if (obj == Py_False) {
3388 if (val) *val = false;
3389 return SWIG_OK;
3390 } else {
3391 long v = 0;
3392 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3393 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3394 return res;
3395 }
3396 }
3397
3398 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3399 wxFileName fname = wxFileSystem::URLToFileName(url);
3400 return fname.GetFullPath();
3401 }
3402
3403 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3404 wxImage& image,
3405 long type) {
3406 wxMemoryFSHandler::AddFile(filename, image, type);
3407 }
3408
3409 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3410 const wxBitmap& bitmap,
3411 long type) {
3412 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3413 }
3414
3415 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3416 PyObject* data) {
3417 if (! PyString_Check(data)) {
3418 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3419 "Expected string object"));
3420 return;
3421 }
3422
3423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3424 void* ptr = (void*)PyString_AsString(data);
3425 size_t size = PyString_Size(data);
3426 wxPyEndBlockThreads(blocked);
3427
3428 wxMemoryFSHandler::AddFile(filename, ptr, size);
3429 }
3430
3431
3432 #include "wx/wxPython/pyistream.h"
3433
3434
3435 SWIGINTERN int
3436 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3437 {
3438 long v = 0;
3439 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3440 return SWIG_TypeError;
3441 }
3442 else if (val)
3443 *val = (unsigned long)v;
3444 return SWIG_OK;
3445 }
3446
3447
3448 SWIGINTERN int
3449 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3450 {
3451 unsigned long v;
3452 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3453 if (SWIG_IsOK(res)) {
3454 if ((v > UCHAR_MAX)) {
3455 return SWIG_OverflowError;
3456 } else {
3457 if (val) *val = static_cast< unsigned char >(v);
3458 }
3459 }
3460 return res;
3461 }
3462
3463
3464 SWIGINTERNINLINE PyObject *
3465 SWIG_From_unsigned_SS_char (unsigned char value)
3466 {
3467 return SWIG_From_unsigned_SS_long (value);
3468 }
3469
3470 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3471 wxImageHistogramEntry e = (*self)[key];
3472 return e.value;
3473 }
3474 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3475 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3476 wxImageHistogramEntry e = (*self)[key];
3477 return e.value;
3478 }
3479 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3480 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3481 colour.Green(),
3482 colour.Blue());
3483 wxImageHistogramEntry e = (*self)[key];
3484 return e.value;
3485 }
3486
3487 // Pull the nested class out to the top level for SWIG's sake
3488 #define wxImage_RGBValue wxImage::RGBValue
3489 #define wxImage_HSVValue wxImage::HSVValue
3490
3491 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3492 if (width > 0 && height > 0)
3493 return new wxImage(width, height, clear);
3494 else
3495 return new wxImage;
3496 }
3497 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3498 return new wxImage(bitmap.ConvertToImage());
3499 }
3500 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3501 if (DATASIZE != width*height*3) {
3502 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3503 return NULL;
3504 }
3505
3506 // Copy the source data so the wxImage can clean it up later
3507 buffer copy = (buffer)malloc(DATASIZE);
3508 if (copy == NULL) {
3509 wxPyBLOCK_THREADS(PyErr_NoMemory());
3510 return NULL;
3511 }
3512 memcpy(copy, data, DATASIZE);
3513 return new wxImage(width, height, copy, false);
3514 }
3515 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3516 if (DATASIZE != width*height*3) {
3517 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3518 return NULL;
3519 }
3520 if (ALPHASIZE != width*height) {
3521 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3522 return NULL;
3523 }
3524
3525 // Copy the source data so the wxImage can clean it up later
3526 buffer dcopy = (buffer)malloc(DATASIZE);
3527 if (dcopy == NULL) {
3528 wxPyBLOCK_THREADS(PyErr_NoMemory());
3529 return NULL;
3530 }
3531 memcpy(dcopy, data, DATASIZE);
3532
3533 buffer acopy = (buffer)malloc(ALPHASIZE);
3534 if (acopy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return NULL;
3537 }
3538 memcpy(acopy, alpha, ALPHASIZE);
3539
3540 return new wxImage(width, height, dcopy, acopy, false);
3541 }
3542 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3543 wxSize size(self->GetWidth(), self->GetHeight());
3544 return size;
3545 }
3546 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3547 buffer data = self->GetData();
3548 int len = self->GetWidth() * self->GetHeight() * 3;
3549 PyObject* rv;
3550 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3551 return rv;
3552 }
3553 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3554 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3555 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3556 return;
3557 }
3558 buffer copy = (buffer)malloc(DATASIZE);
3559 if (copy == NULL) {
3560 wxPyBLOCK_THREADS(PyErr_NoMemory());
3561 return;
3562 }
3563 memcpy(copy, data, DATASIZE);
3564 self->SetData(copy, false);
3565 // wxImage takes ownership of copy...
3566 }
3567 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3568 buffer data = self->GetData();
3569 int len = self->GetWidth() * self->GetHeight() * 3;
3570 PyObject* rv;
3571 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3572 return rv;
3573 }
3574 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3575 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3577 return;
3578 }
3579 self->SetData(data, true);
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 if (! data) {
3584 RETURN_NONE();
3585 } else {
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3589 return rv;
3590 }
3591 }
3592 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3593 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3594 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3595 return;
3596 }
3597 buffer acopy = (buffer)malloc(ALPHASIZE);
3598 if (acopy == NULL) {
3599 wxPyBLOCK_THREADS(PyErr_NoMemory());
3600 return;
3601 }
3602 memcpy(acopy, alpha, ALPHASIZE);
3603 self->SetAlpha(acopy, false);
3604 // wxImage takes ownership of acopy...
3605 }
3606 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3607 buffer data = self->GetAlpha();
3608 int len = self->GetWidth() * self->GetHeight();
3609 PyObject* rv;
3610 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3611 return rv;
3612 }
3613 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3614 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3615 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3616 return;
3617 }
3618 self->SetAlpha(alpha, true);
3619 }
3620 SWIGINTERN PyObject *wxImage_GetHandlers(){
3621 wxList& list = wxImage::GetHandlers();
3622 return wxPy_ConvertList(&list);
3623 }
3624 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3625 wxBitmap bitmap(*self, depth);
3626 return bitmap;
3627 }
3628 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3629 wxImage mono = self->ConvertToMono( red, green, blue );
3630 wxBitmap bitmap( mono, 1 );
3631 return bitmap;
3632 }
3633
3634 wxImage* _ImageFromBuffer(int width, int height,
3635 buffer data, int DATASIZE,
3636 buffer alpha=NULL, int ALPHASIZE=0)
3637 {
3638 if (DATASIZE != width*height*3) {
3639 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3640 return NULL;
3641 }
3642 if (alpha != NULL) {
3643 if (ALPHASIZE != width*height) {
3644 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3645 return NULL;
3646 }
3647 return new wxImage(width, height, data, alpha, true);
3648 }
3649 return new wxImage(width, height, data, true);
3650 }
3651
3652 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3653 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3660 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3661 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3662 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3663 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3664 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3665 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3666 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3667
3668 #include <wx/quantize.h>
3669
3670 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3671 return wxQuantize::Quantize(src, dest,
3672 //NULL, // palette
3673 desiredNoColours,
3674 NULL, // eightBitData
3675 flags);
3676 }
3677 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3678 if (PyCallable_Check(func)) {
3679 self->Connect(id, lastId, eventType,
3680 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3681 new wxPyCallback(func));
3682 }
3683 else if (func == Py_None) {
3684 self->Disconnect(id, lastId, eventType,
3685 (wxObjectEventFunction)
3686 &wxPyCallback::EventThunker);
3687 }
3688 else {
3689 wxPyBLOCK_THREADS(
3690 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3691 }
3692 }
3693 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3694 return self->Disconnect(id, lastId, eventType,
3695 (wxObjectEventFunction)
3696 &wxPyCallback::EventThunker);
3697 }
3698 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3699 if (_self && _self != Py_None) {
3700 self->SetClientObject(new wxPyOORClientData(_self, incref));
3701 }
3702 else {
3703 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3704 if (data) {
3705 self->SetClientObject(NULL); // This will delete it too
3706 }
3707 }
3708 }
3709
3710 #if ! wxUSE_HOTKEY
3711 #define wxEVT_HOTKEY -9999
3712 #endif
3713
3714 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3715 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3716 if (data) {
3717 Py_INCREF(data->m_obj);
3718 return data->m_obj;
3719 } else {
3720 Py_INCREF(Py_None);
3721 return Py_None;
3722 }
3723 }
3724 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3725 wxPyClientData* data = new wxPyClientData(clientData);
3726 self->SetClientObject(data);
3727 }
3728 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3729 #if wxUSE_UNICODE
3730 return self->GetUnicodeKey();
3731 #else
3732 return 0;
3733 #endif
3734 }
3735 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3736 #if wxUSE_UNICODE
3737 self->m_uniChar = uniChar;
3738 #endif
3739 }
3740
3741 SWIGINTERNINLINE PyObject *
3742 SWIG_From_unsigned_SS_int (unsigned int value)
3743 {
3744 return SWIG_From_unsigned_SS_long (value);
3745 }
3746
3747
3748 SWIGINTERN int
3749 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3750 {
3751 unsigned long v;
3752 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3753 if (SWIG_IsOK(res)) {
3754 if ((v > UINT_MAX)) {
3755 return SWIG_OverflowError;
3756 } else {
3757 if (val) *val = static_cast< unsigned int >(v);
3758 }
3759 }
3760 return res;
3761 }
3762
3763 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3764 self->m_size = size;
3765 }
3766 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3767 int count = self->GetNumberOfFiles();
3768 wxString* files = self->GetFiles();
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 PyObject* list = PyList_New(count);
3771
3772 if (!list) {
3773 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3774 wxPyEndBlockThreads(blocked);
3775 return NULL;
3776 }
3777
3778 for (int i=0; i<count; i++) {
3779 PyList_SetItem(list, i, wx2PyString(files[i]));
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return list;
3783 }
3784
3785
3786 SWIGINTERN wxPyApp *new_wxPyApp(){
3787 wxPythonApp = new wxPyApp();
3788 return wxPythonApp;
3789 }
3790 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3791 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3792 return wxPyTestDisplayAvailable();
3793 }
3794
3795 void wxApp_CleanUp() {
3796 __wxPyCleanup();
3797 }
3798
3799
3800 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3801
3802
3803
3804
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_FromCharPtr(const char *cptr)
3808 {
3809 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3810 }
3811
3812
3813 #if 0 // #ifdef __WXMAC__
3814
3815 // A dummy class that raises an exception if used...
3816 class wxEventLoop
3817 {
3818 public:
3819 wxEventLoop() { wxPyRaiseNotImplemented(); }
3820 int Run() { return 0; }
3821 void Exit(int rc = 0) {}
3822 bool Pending() const { return false; }
3823 bool Dispatch() { return false; }
3824 bool IsRunning() const { return false; }
3825 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3826 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3827 };
3828
3829 #else
3830
3831 #include <wx/evtloop.h>
3832
3833 #endif
3834
3835
3836
3837 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3838 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3839 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3840 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3841 wxWindowList& list = self->GetChildren();
3842 return wxPy_ConvertList(&list);
3843 }
3844 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3845 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3846 #if wxUSE_HOTKEY
3847 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3848 #else
3849 return false;
3850 #endif
3851 }
3852 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3853
3854
3855
3856 return false;
3857
3858 }
3859 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3860 return wxPyGetWinHandle(self);
3861 }
3862 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3863 self->AssociateHandle((WXWidget)handle);
3864 }
3865 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3866
3867 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3868 return wxWindow::FindWindowById(id, parent);
3869 }
3870
3871 wxWindow* wxFindWindowByName( const wxString& name,
3872 const wxWindow *parent = NULL ) {
3873 return wxWindow::FindWindowByName(name, parent);
3874 }
3875
3876 wxWindow* wxFindWindowByLabel( const wxString& label,
3877 const wxWindow *parent = NULL ) {
3878 return wxWindow::FindWindowByLabel(label, parent);
3879 }
3880
3881
3882 #ifdef __WXMSW__
3883 #include <wx/msw/private.h> // to get wxGetWindowId
3884 #endif
3885
3886
3887 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3888 #ifdef __WXMSW__
3889 WXHWND hWnd = (WXHWND)_hWnd;
3890 long id = wxGetWindowId(hWnd);
3891 wxWindow* win = new wxWindow;
3892 if (parent)
3893 parent->AddChild(win);
3894 win->SetEventHandler(win);
3895 win->SetHWND(hWnd);
3896 win->SetId(id);
3897 win->SubclassWin(hWnd);
3898 win->AdoptAttributesFromHWND();
3899 win->SetupColours();
3900 return win;
3901 #else
3902 wxPyRaiseNotImplemented();
3903 return NULL;
3904 #endif
3905 }
3906
3907
3908 PyObject* GetTopLevelWindows() {
3909 return wxPy_ConvertList(&wxTopLevelWindows);
3910 }
3911
3912
3913 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3915 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3916
3917 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3918
3919
3920 SWIGINTERNINLINE int
3921 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3922 {
3923 unsigned long v;
3924 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3925 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3926 return res;
3927 }
3928
3929 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3930 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3931 wxMenuItemList& list = self->GetMenuItems();
3932 return wxPy_ConvertList(&list);
3933 }
3934 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3935 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3936 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3937 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3938 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3939 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3941 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3942 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3943 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3944 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3945 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3946 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3947 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3948 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3949 static const wxString wxPyControlNameStr(wxControlNameStr);
3950 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3951 if (clientData) {
3952 wxPyClientData* data = new wxPyClientData(clientData);
3953 return self->Append(item, data);
3954 } else
3955 return self->Append(item);
3956 }
3957 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3958 if (clientData) {
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 return self->Insert(item, pos, data);
3961 } else
3962 return self->Insert(item, pos);
3963 }
3964 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3965 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3966 if (data) {
3967 Py_INCREF(data->m_obj);
3968 return data->m_obj;
3969 } else {
3970 Py_INCREF(Py_None);
3971 return Py_None;
3972 }
3973 }
3974 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3975 wxPyClientData* data = new wxPyClientData(clientData);
3976 self->SetClientObject(n, data);
3977 }
3978
3979
3980 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3981 wxPyUserData* data = NULL;
3982 if ( userData ) {
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 data = new wxPyUserData(userData);
3985 wxPyEndBlockThreads(blocked);
3986 }
3987 return new wxSizerItem(window, proportion, flag, border, data);
3988 }
3989 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 return new wxSizerItem(width, height, proportion, flag, border, data);
3997 }
3998 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3999 wxPyUserData* data = NULL;
4000 if ( userData ) {
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 data = new wxPyUserData(userData);
4003 wxPyEndBlockThreads(blocked);
4004 }
4005 return new wxSizerItem(sizer, proportion, flag, border, data);
4006 }
4007
4008 SWIGINTERNINLINE PyObject *
4009 SWIG_From_float (float value)
4010 {
4011 return SWIG_From_double (value);
4012 }
4013
4014 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4015 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4016 if (data) {
4017 Py_INCREF(data->m_obj);
4018 return data->m_obj;
4019 } else {
4020 Py_INCREF(Py_None);
4021 return Py_None;
4022 }
4023 }
4024 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 self->SetUserData(data);
4032 }
4033
4034 // Figure out the type of the sizer item
4035
4036 struct wxPySizerItemInfo {
4037 wxPySizerItemInfo()
4038 : window(NULL), sizer(NULL), gotSize(false),
4039 size(wxDefaultSize), gotPos(false), pos(-1)
4040 {}
4041
4042 wxWindow* window;
4043 wxSizer* sizer;
4044 bool gotSize;
4045 wxSize size;
4046 bool gotPos;
4047 int pos;
4048 };
4049
4050 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4051
4052 wxPySizerItemInfo info;
4053 wxSize size;
4054 wxSize* sizePtr = &size;
4055
4056 // Find out what the type of the item is
4057 // try wxWindow
4058 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4059 PyErr_Clear();
4060 info.window = NULL;
4061
4062 // try wxSizer
4063 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4064 PyErr_Clear();
4065 info.sizer = NULL;
4066
4067 // try wxSize or (w,h)
4068 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4069 info.size = *sizePtr;
4070 info.gotSize = true;
4071 }
4072
4073 // or a single int
4074 if (checkIdx && PyInt_Check(item)) {
4075 info.pos = PyInt_AsLong(item);
4076 info.gotPos = true;
4077 }
4078 }
4079 }
4080
4081 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4082 // no expected type, figure out what kind of error message to generate
4083 if ( !checkSize && !checkIdx )
4084 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4085 else if ( checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4087 else if ( !checkSize && checkIdx)
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4089 else
4090 // can this one happen?
4091 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4092 }
4093
4094 return info;
4095 }
4096
4097 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4098 if (!self->GetClientObject())
4099 self->SetClientObject(new wxPyOORClientData(_self));
4100 }
4101 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4102
4103 wxPyUserData* data = NULL;
4104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4105 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4106 if ( userData && (info.window || info.sizer || info.gotSize) )
4107 data = new wxPyUserData(userData);
4108 if ( info.sizer )
4109 PyObject_SetAttrString(item,"thisown",Py_False);
4110 wxPyEndBlockThreads(blocked);
4111
4112 // Now call the real Add method if a valid item type was found
4113 if ( info.window )
4114 return self->Add(info.window, proportion, flag, border, data);
4115 else if ( info.sizer )
4116 return self->Add(info.sizer, proportion, flag, border, data);
4117 else if (info.gotSize)
4118 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4119 proportion, flag, border, data);
4120 else
4121 return NULL;
4122 }
4123 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4124
4125 wxPyUserData* data = NULL;
4126 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4127 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4128 if ( userData && (info.window || info.sizer || info.gotSize) )
4129 data = new wxPyUserData(userData);
4130 if ( info.sizer )
4131 PyObject_SetAttrString(item,"thisown",Py_False);
4132 wxPyEndBlockThreads(blocked);
4133
4134 // Now call the real Insert method if a valid item type was found
4135 if ( info.window )
4136 return self->Insert(before, info.window, proportion, flag, border, data);
4137 else if ( info.sizer )
4138 return self->Insert(before, info.sizer, proportion, flag, border, data);
4139 else if (info.gotSize)
4140 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4141 proportion, flag, border, data);
4142 else
4143 return NULL;
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Prepend method if a valid item type was found
4157 if ( info.window )
4158 return self->Prepend(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Prepend(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4170 wxPyEndBlockThreads(blocked);
4171 if ( info.window )
4172 return self->Remove(info.window);
4173 else if ( info.sizer )
4174 return self->Remove(info.sizer);
4175 else if ( info.gotPos )
4176 return self->Remove(info.pos);
4177 else
4178 return false;
4179 }
4180 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4183 wxPyEndBlockThreads(blocked);
4184 if ( info.window )
4185 return self->Detach(info.window);
4186 else if ( info.sizer )
4187 return self->Detach(info.sizer);
4188 else if ( info.gotPos )
4189 return self->Detach(info.pos);
4190 else
4191 return false;
4192 }
4193 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4195 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4196 wxPyEndBlockThreads(blocked);
4197 if ( info.window )
4198 return self->GetItem(info.window);
4199 else if ( info.sizer )
4200 return self->GetItem(info.sizer);
4201 else if ( info.gotPos )
4202 return self->GetItem(info.pos);
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 self->SetItemMinSize(info.window, size);
4212 else if ( info.sizer )
4213 self->SetItemMinSize(info.sizer, size);
4214 else if ( info.gotPos )
4215 self->SetItemMinSize(info.pos, size);
4216 }
4217 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4218 wxSizerItemList& list = self->GetChildren();
4219 return wxPy_ConvertList(&list);
4220 }
4221 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->Show(info.window, show, recursive);
4227 else if ( info.sizer )
4228 return self->Show(info.sizer, show, recursive);
4229 else if ( info.gotPos )
4230 return self->Show(info.pos, show);
4231 else
4232 return false;
4233 }
4234 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 return self->IsShown(info.window);
4240 else if ( info.sizer )
4241 return self->IsShown(info.sizer);
4242 else if ( info.gotPos )
4243 return self->IsShown(info.pos);
4244 else
4245 return false;
4246 }
4247
4248 // See pyclasses.h
4249 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4250 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4251 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4252
4253
4254
4255
4256 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4257 {
4258 if (source == Py_None) {
4259 **obj = wxGBPosition(-1,-1);
4260 return true;
4261 }
4262 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4263 }
4264
4265 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4266 {
4267 if (source == Py_None) {
4268 **obj = wxGBSpan(-1,-1);
4269 return true;
4270 }
4271 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4272 }
4273
4274
4275 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4276 wxGBPosition temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBPosition_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4285 wxGBPosition temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBPosition_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4294 self->SetRow(row);
4295 self->SetCol(col);
4296 }
4297 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4306 wxGBSpan temp, *obj = &temp;
4307 if ( other == Py_None ) return false;
4308 if ( ! wxGBSpan_helper(other, &obj) ) {
4309 PyErr_Clear();
4310 return false;
4311 }
4312 return self->operator==(*obj);
4313 }
4314 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4315 wxGBSpan temp, *obj = &temp;
4316 if ( other == Py_None ) return true;
4317 if ( ! wxGBSpan_helper(other, &obj)) {
4318 PyErr_Clear();
4319 return true;
4320 }
4321 return self->operator!=(*obj);
4322 }
4323 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4324 self->SetRowspan(rowspan);
4325 self->SetColspan(colspan);
4326 }
4327 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 PyObject* tup = PyTuple_New(2);
4330 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4331 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4332 wxPyEndBlockThreads(blocked);
4333 return tup;
4334 }
4335 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4336 wxPyUserData* data = NULL;
4337 if ( userData ) {
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 data = new wxPyUserData(userData);
4340 wxPyEndBlockThreads(blocked);
4341 }
4342 return new wxGBSizerItem(window, pos, span, flag, border, data);
4343 }
4344 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4345 wxPyUserData* data = NULL;
4346 if ( userData ) {
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 data = new wxPyUserData(userData);
4349 wxPyEndBlockThreads(blocked);
4350 }
4351 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4352 }
4353 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4354 wxPyUserData* data = NULL;
4355 if ( userData ) {
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 data = new wxPyUserData(userData);
4358 wxPyEndBlockThreads(blocked);
4359 }
4360 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4361 }
4362 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4363 int row, col;
4364 self->GetEndPos(row, col);
4365 return wxGBPosition(row, col);
4366 }
4367 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4368
4369 wxPyUserData* data = NULL;
4370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4371 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4372 if ( userData && (info.window || info.sizer || info.gotSize) )
4373 data = new wxPyUserData(userData);
4374 if ( info.sizer )
4375 PyObject_SetAttrString(item,"thisown",Py_False);
4376 wxPyEndBlockThreads(blocked);
4377
4378 // Now call the real Add method if a valid item type was found
4379 if ( info.window )
4380 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4381 else if ( info.sizer )
4382 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4383 else if (info.gotSize)
4384 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4385 pos, span, flag, border, data);
4386 return NULL;
4387 }
4388
4389
4390 #ifdef __cplusplus
4391 extern "C" {
4392 #endif
4393 SWIGINTERN int EmptyString_set(PyObject *) {
4394 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4395 return 1;
4396 }
4397
4398
4399 SWIGINTERN PyObject *EmptyString_get(void) {
4400 PyObject *pyobj = 0;
4401
4402 {
4403 #if wxUSE_UNICODE
4404 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4405 #else
4406 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #endif
4408 }
4409 return pyobj;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 wxString result;
4417 void *argp1 = 0 ;
4418 int res1 = 0 ;
4419 PyObject *swig_obj[1] ;
4420
4421 if (!args) SWIG_fail;
4422 swig_obj[0] = args;
4423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4424 if (!SWIG_IsOK(res1)) {
4425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4426 }
4427 arg1 = reinterpret_cast< wxObject * >(argp1);
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = wxObject_GetClassName(arg1);
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 {
4435 #if wxUSE_UNICODE
4436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4437 #else
4438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4439 #endif
4440 }
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxObject *arg1 = (wxObject *) 0 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 PyObject *swig_obj[1] ;
4453
4454 if (!args) SWIG_fail;
4455 swig_obj[0] = args;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4459 }
4460 arg1 = reinterpret_cast< wxObject * >(argp1);
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 wxObject_Destroy(arg1);
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475 PyObject *obj;
4476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4477 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4478 return SWIG_Py_Void();
4479 }
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int arg2 ;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 int val2 ;
4488 int ecode2 = 0 ;
4489 PyObject *swig_obj[2] ;
4490
4491 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4493 if (!SWIG_IsOK(res1)) {
4494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4495 }
4496 arg1 = reinterpret_cast< wxSize * >(argp1);
4497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4498 if (!SWIG_IsOK(ecode2)) {
4499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4500 }
4501 arg2 = static_cast< int >(val2);
4502 if (arg1) (arg1)->x = arg2;
4503
4504 resultobj = SWIG_Py_Void();
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4512 PyObject *resultobj = 0;
4513 wxSize *arg1 = (wxSize *) 0 ;
4514 int result;
4515 void *argp1 = 0 ;
4516 int res1 = 0 ;
4517 PyObject *swig_obj[1] ;
4518
4519 if (!args) SWIG_fail;
4520 swig_obj[0] = args;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 result = (int) ((arg1)->x);
4527 resultobj = SWIG_From_int(static_cast< int >(result));
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int arg2 ;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 int val2 ;
4541 int ecode2 = 0 ;
4542 PyObject *swig_obj[2] ;
4543
4544 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4548 }
4549 arg1 = reinterpret_cast< wxSize * >(argp1);
4550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4551 if (!SWIG_IsOK(ecode2)) {
4552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4553 }
4554 arg2 = static_cast< int >(val2);
4555 if (arg1) (arg1)->y = arg2;
4556
4557 resultobj = SWIG_Py_Void();
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxSize *arg1 = (wxSize *) 0 ;
4567 int result;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4577 }
4578 arg1 = reinterpret_cast< wxSize * >(argp1);
4579 result = (int) ((arg1)->y);
4580 resultobj = SWIG_From_int(static_cast< int >(result));
4581 return resultobj;
4582 fail:
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4588 PyObject *resultobj = 0;
4589 int arg1 = (int) 0 ;
4590 int arg2 = (int) 0 ;
4591 wxSize *result = 0 ;
4592 int val1 ;
4593 int ecode1 = 0 ;
4594 int val2 ;
4595 int ecode2 = 0 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char * kwnames[] = {
4599 (char *) "w",(char *) "h", NULL
4600 };
4601
4602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4603 if (obj0) {
4604 ecode1 = SWIG_AsVal_int(obj0, &val1);
4605 if (!SWIG_IsOK(ecode1)) {
4606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4607 }
4608 arg1 = static_cast< int >(val1);
4609 }
4610 if (obj1) {
4611 ecode2 = SWIG_AsVal_int(obj1, &val2);
4612 if (!SWIG_IsOK(ecode2)) {
4613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4614 }
4615 arg2 = static_cast< int >(val2);
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 result = (wxSize *)new wxSize(arg1,arg2);
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4624 return resultobj;
4625 fail:
4626 return NULL;
4627 }
4628
4629
4630 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 PyObject *resultobj = 0;
4632 wxSize *arg1 = (wxSize *) 0 ;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject *swig_obj[1] ;
4636
4637 if (!args) SWIG_fail;
4638 swig_obj[0] = args;
4639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4642 }
4643 arg1 = reinterpret_cast< wxSize * >(argp1);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 delete arg1;
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_Py_Void();
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj = 0;
4660 wxSize *arg1 = (wxSize *) 0 ;
4661 PyObject *arg2 = (PyObject *) 0 ;
4662 bool result;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "self",(char *) "other", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4675 }
4676 arg1 = reinterpret_cast< wxSize * >(argp1);
4677 arg2 = obj1;
4678 {
4679 result = (bool)wxSize___eq__(arg1,arg2);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 {
4683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4684 }
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj = 0;
4693 wxSize *arg1 = (wxSize *) 0 ;
4694 PyObject *arg2 = (PyObject *) 0 ;
4695 bool result;
4696 void *argp1 = 0 ;
4697 int res1 = 0 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "other", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 arg2 = obj1;
4711 {
4712 result = (bool)wxSize___ne__(arg1,arg2);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4717 }
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 wxSize *arg2 = 0 ;
4728 wxSize result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 wxSize temp2 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 char * kwnames[] = {
4735 (char *) "self",(char *) "sz", NULL
4736 };
4737
4738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4740 if (!SWIG_IsOK(res1)) {
4741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4742 }
4743 arg1 = reinterpret_cast< wxSize * >(argp1);
4744 {
4745 arg2 = &temp2;
4746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = (arg1)->operator +((wxSize const &)*arg2);
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 wxSize *arg1 = (wxSize *) 0 ;
4764 wxSize *arg2 = 0 ;
4765 wxSize result;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 result = (arg1)->operator -((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->IncTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 wxSize *arg2 = 0 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 wxSize temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char * kwnames[] = {
4844 (char *) "self",(char *) "sz", NULL
4845 };
4846
4847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4849 if (!SWIG_IsOK(res1)) {
4850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4851 }
4852 arg1 = reinterpret_cast< wxSize * >(argp1);
4853 {
4854 arg2 = &temp2;
4855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4856 }
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 (arg1)->DecTo((wxSize const &)*arg2);
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj = 0;
4872 wxSize *arg1 = (wxSize *) 0 ;
4873 float arg2 ;
4874 float arg3 ;
4875 void *argp1 = 0 ;
4876 int res1 = 0 ;
4877 float val2 ;
4878 int ecode2 = 0 ;
4879 float val3 ;
4880 int ecode3 = 0 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 PyObject * obj2 = 0 ;
4884 char * kwnames[] = {
4885 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4886 };
4887
4888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4890 if (!SWIG_IsOK(res1)) {
4891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4892 }
4893 arg1 = reinterpret_cast< wxSize * >(argp1);
4894 ecode2 = SWIG_AsVal_float(obj1, &val2);
4895 if (!SWIG_IsOK(ecode2)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4897 }
4898 arg2 = static_cast< float >(val2);
4899 ecode3 = SWIG_AsVal_float(obj2, &val3);
4900 if (!SWIG_IsOK(ecode3)) {
4901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4902 }
4903 arg3 = static_cast< float >(val3);
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 (arg1)->Scale(arg2,arg3);
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_Py_Void();
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 int arg2 ;
4921 int arg3 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 int val2 ;
4925 int ecode2 = 0 ;
4926 int val3 ;
4927 int ecode3 = 0 ;
4928 PyObject * obj0 = 0 ;
4929 PyObject * obj1 = 0 ;
4930 PyObject * obj2 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "w",(char *) "h", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4937 if (!SWIG_IsOK(res1)) {
4938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4939 }
4940 arg1 = reinterpret_cast< wxSize * >(argp1);
4941 ecode2 = SWIG_AsVal_int(obj1, &val2);
4942 if (!SWIG_IsOK(ecode2)) {
4943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 ecode3 = SWIG_AsVal_int(obj2, &val3);
4947 if (!SWIG_IsOK(ecode3)) {
4948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4949 }
4950 arg3 = static_cast< int >(val3);
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 (arg1)->Set(arg2,arg3);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_Py_Void();
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxSize *arg1 = (wxSize *) 0 ;
4967 int arg2 ;
4968 void *argp1 = 0 ;
4969 int res1 = 0 ;
4970 int val2 ;
4971 int ecode2 = 0 ;
4972 PyObject * obj0 = 0 ;
4973 PyObject * obj1 = 0 ;
4974 char * kwnames[] = {
4975 (char *) "self",(char *) "w", NULL
4976 };
4977
4978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 ecode2 = SWIG_AsVal_int(obj1, &val2);
4985 if (!SWIG_IsOK(ecode2)) {
4986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4987 }
4988 arg2 = static_cast< int >(val2);
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 (arg1)->SetWidth(arg2);
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 resultobj = SWIG_Py_Void();
4996 return resultobj;
4997 fail:
4998 return NULL;
4999 }
5000
5001
5002 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj = 0;
5004 wxSize *arg1 = (wxSize *) 0 ;
5005 int arg2 ;
5006 void *argp1 = 0 ;
5007 int res1 = 0 ;
5008 int val2 ;
5009 int ecode2 = 0 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "self",(char *) "h", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5020 }
5021 arg1 = reinterpret_cast< wxSize * >(argp1);
5022 ecode2 = SWIG_AsVal_int(obj1, &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5025 }
5026 arg2 = static_cast< int >(val2);
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 (arg1)->SetHeight(arg2);
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 resultobj = SWIG_Py_Void();
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5041 PyObject *resultobj = 0;
5042 wxSize *arg1 = (wxSize *) 0 ;
5043 int result;
5044 void *argp1 = 0 ;
5045 int res1 = 0 ;
5046 PyObject *swig_obj[1] ;
5047
5048 if (!args) SWIG_fail;
5049 swig_obj[0] = args;
5050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5051 if (!SWIG_IsOK(res1)) {
5052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5053 }
5054 arg1 = reinterpret_cast< wxSize * >(argp1);
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 result = (int)((wxSize const *)arg1)->GetWidth();
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_From_int(static_cast< int >(result));
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 PyObject *resultobj = 0;
5070 wxSize *arg1 = (wxSize *) 0 ;
5071 int result;
5072 void *argp1 = 0 ;
5073 int res1 = 0 ;
5074 PyObject *swig_obj[1] ;
5075
5076 if (!args) SWIG_fail;
5077 swig_obj[0] = args;
5078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5081 }
5082 arg1 = reinterpret_cast< wxSize * >(argp1);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = (int)((wxSize const *)arg1)->GetHeight();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_From_int(static_cast< int >(result));
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxSize *arg1 = (wxSize *) 0 ;
5099 bool result;
5100 void *argp1 = 0 ;
5101 int res1 = 0 ;
5102 PyObject *swig_obj[1] ;
5103
5104 if (!args) SWIG_fail;
5105 swig_obj[0] = args;
5106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5107 if (!SWIG_IsOK(res1)) {
5108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5109 }
5110 arg1 = reinterpret_cast< wxSize * >(argp1);
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5119 }
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 wxSize *arg2 = 0 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 wxSize temp2 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "size", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 {
5146 arg2 = &temp2;
5147 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5148 }
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 (arg1)->SetDefaults((wxSize const &)*arg2);
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 PyObject *result = 0 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 PyObject *swig_obj[1] ;
5169
5170 if (!args) SWIG_fail;
5171 swig_obj[0] = args;
5172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5175 }
5176 arg1 = reinterpret_cast< wxSize * >(argp1);
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 result = (PyObject *)wxSize_Get(arg1);
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 resultobj = result;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5191 PyObject *obj;
5192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5193 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5194 return SWIG_Py_Void();
5195 }
5196
5197 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 return SWIG_Python_InitShadowInstance(args);
5199 }
5200
5201 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5204 double arg2 ;
5205 void *argp1 = 0 ;
5206 int res1 = 0 ;
5207 double val2 ;
5208 int ecode2 = 0 ;
5209 PyObject *swig_obj[2] ;
5210
5211 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5215 }
5216 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5217 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5218 if (!SWIG_IsOK(ecode2)) {
5219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5220 }
5221 arg2 = static_cast< double >(val2);
5222 if (arg1) (arg1)->x = arg2;
5223
5224 resultobj = SWIG_Py_Void();
5225 return resultobj;
5226 fail:
5227 return NULL;
5228 }
5229
5230
5231 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5232 PyObject *resultobj = 0;
5233 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5234 double result;
5235 void *argp1 = 0 ;
5236 int res1 = 0 ;
5237 PyObject *swig_obj[1] ;
5238
5239 if (!args) SWIG_fail;
5240 swig_obj[0] = args;
5241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5242 if (!SWIG_IsOK(res1)) {
5243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5244 }
5245 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5246 result = (double) ((arg1)->x);
5247 resultobj = SWIG_From_double(static_cast< double >(result));
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5255 PyObject *resultobj = 0;
5256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5257 double arg2 ;
5258 void *argp1 = 0 ;
5259 int res1 = 0 ;
5260 double val2 ;
5261 int ecode2 = 0 ;
5262 PyObject *swig_obj[2] ;
5263
5264 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5266 if (!SWIG_IsOK(res1)) {
5267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5268 }
5269 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5270 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5271 if (!SWIG_IsOK(ecode2)) {
5272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5273 }
5274 arg2 = static_cast< double >(val2);
5275 if (arg1) (arg1)->y = arg2;
5276
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285 PyObject *resultobj = 0;
5286 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5287 double result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 PyObject *swig_obj[1] ;
5291
5292 if (!args) SWIG_fail;
5293 swig_obj[0] = args;
5294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5295 if (!SWIG_IsOK(res1)) {
5296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5297 }
5298 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5299 result = (double) ((arg1)->y);
5300 resultobj = SWIG_From_double(static_cast< double >(result));
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 double arg1 = (double) 0.0 ;
5310 double arg2 = (double) 0.0 ;
5311 wxRealPoint *result = 0 ;
5312 double val1 ;
5313 int ecode1 = 0 ;
5314 double val2 ;
5315 int ecode2 = 0 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "x",(char *) "y", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5323 if (obj0) {
5324 ecode1 = SWIG_AsVal_double(obj0, &val1);
5325 if (!SWIG_IsOK(ecode1)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5327 }
5328 arg1 = static_cast< double >(val1);
5329 }
5330 if (obj1) {
5331 ecode2 = SWIG_AsVal_double(obj1, &val2);
5332 if (!SWIG_IsOK(ecode2)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5334 }
5335 arg2 = static_cast< double >(val2);
5336 }
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 PyObject *swig_obj[1] ;
5356
5357 if (!args) SWIG_fail;
5358 swig_obj[0] = args;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 delete arg1;
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 PyObject *arg2 = (PyObject *) 0 ;
5382 bool result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 char * kwnames[] = {
5388 (char *) "self",(char *) "other", NULL
5389 };
5390
5391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 arg2 = obj1;
5398 {
5399 result = (bool)wxRealPoint___eq__(arg1,arg2);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5404 }
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5412 PyObject *resultobj = 0;
5413 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5414 PyObject *arg2 = (PyObject *) 0 ;
5415 bool result;
5416 void *argp1 = 0 ;
5417 int res1 = 0 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "self",(char *) "other", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5426 if (!SWIG_IsOK(res1)) {
5427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5428 }
5429 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5430 arg2 = obj1;
5431 {
5432 result = (bool)wxRealPoint___ne__(arg1,arg2);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj = 0;
5446 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5447 wxRealPoint *arg2 = 0 ;
5448 wxRealPoint result;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 wxRealPoint temp2 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "pt", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5462 }
5463 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5464 {
5465 arg2 = &temp2;
5466 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5467 }
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj = 0;
5483 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5484 wxRealPoint *arg2 = 0 ;
5485 wxRealPoint result;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 wxRealPoint temp2 ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 char * kwnames[] = {
5492 (char *) "self",(char *) "pt", NULL
5493 };
5494
5495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5499 }
5500 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5501 {
5502 arg2 = &temp2;
5503 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5521 double arg2 ;
5522 double arg3 ;
5523 void *argp1 = 0 ;
5524 int res1 = 0 ;
5525 double val2 ;
5526 int ecode2 = 0 ;
5527 double val3 ;
5528 int ecode3 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 PyObject * obj2 = 0 ;
5532 char * kwnames[] = {
5533 (char *) "self",(char *) "x",(char *) "y", NULL
5534 };
5535
5536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5542 ecode2 = SWIG_AsVal_double(obj1, &val2);
5543 if (!SWIG_IsOK(ecode2)) {
5544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5545 }
5546 arg2 = static_cast< double >(val2);
5547 ecode3 = SWIG_AsVal_double(obj2, &val3);
5548 if (!SWIG_IsOK(ecode3)) {
5549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5550 }
5551 arg3 = static_cast< double >(val3);
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 wxRealPoint_Set(arg1,arg2,arg3);
5555 wxPyEndAllowThreads(__tstate);
5556 if (PyErr_Occurred()) SWIG_fail;
5557 }
5558 resultobj = SWIG_Py_Void();
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566 PyObject *resultobj = 0;
5567 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5568 PyObject *result = 0 ;
5569 void *argp1 = 0 ;
5570 int res1 = 0 ;
5571 PyObject *swig_obj[1] ;
5572
5573 if (!args) SWIG_fail;
5574 swig_obj[0] = args;
5575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5576 if (!SWIG_IsOK(res1)) {
5577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5578 }
5579 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (PyObject *)wxRealPoint_Get(arg1);
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = result;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *obj;
5595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5596 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5597 return SWIG_Py_Void();
5598 }
5599
5600 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 return SWIG_Python_InitShadowInstance(args);
5602 }
5603
5604 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5605 PyObject *resultobj = 0;
5606 wxPoint *arg1 = (wxPoint *) 0 ;
5607 int arg2 ;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 int val2 ;
5611 int ecode2 = 0 ;
5612 PyObject *swig_obj[2] ;
5613
5614 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5623 }
5624 arg2 = static_cast< int >(val2);
5625 if (arg1) (arg1)->x = arg2;
5626
5627 resultobj = SWIG_Py_Void();
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 PyObject *resultobj = 0;
5636 wxPoint *arg1 = (wxPoint *) 0 ;
5637 int result;
5638 void *argp1 = 0 ;
5639 int res1 = 0 ;
5640 PyObject *swig_obj[1] ;
5641
5642 if (!args) SWIG_fail;
5643 swig_obj[0] = args;
5644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5645 if (!SWIG_IsOK(res1)) {
5646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5647 }
5648 arg1 = reinterpret_cast< wxPoint * >(argp1);
5649 result = (int) ((arg1)->x);
5650 resultobj = SWIG_From_int(static_cast< int >(result));
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5658 PyObject *resultobj = 0;
5659 wxPoint *arg1 = (wxPoint *) 0 ;
5660 int arg2 ;
5661 void *argp1 = 0 ;
5662 int res1 = 0 ;
5663 int val2 ;
5664 int ecode2 = 0 ;
5665 PyObject *swig_obj[2] ;
5666
5667 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5671 }
5672 arg1 = reinterpret_cast< wxPoint * >(argp1);
5673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5674 if (!SWIG_IsOK(ecode2)) {
5675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5676 }
5677 arg2 = static_cast< int >(val2);
5678 if (arg1) (arg1)->y = arg2;
5679
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxPoint *arg1 = (wxPoint *) 0 ;
5690 int result;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject *swig_obj[1] ;
5694
5695 if (!args) SWIG_fail;
5696 swig_obj[0] = args;
5697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxPoint * >(argp1);
5702 result = (int) ((arg1)->y);
5703 resultobj = SWIG_From_int(static_cast< int >(result));
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 int arg1 = (int) 0 ;
5713 int arg2 = (int) 0 ;
5714 wxPoint *result = 0 ;
5715 int val1 ;
5716 int ecode1 = 0 ;
5717 int val2 ;
5718 int ecode2 = 0 ;
5719 PyObject * obj0 = 0 ;
5720 PyObject * obj1 = 0 ;
5721 char * kwnames[] = {
5722 (char *) "x",(char *) "y", NULL
5723 };
5724
5725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5726 if (obj0) {
5727 ecode1 = SWIG_AsVal_int(obj0, &val1);
5728 if (!SWIG_IsOK(ecode1)) {
5729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5730 }
5731 arg1 = static_cast< int >(val1);
5732 }
5733 if (obj1) {
5734 ecode2 = SWIG_AsVal_int(obj1, &val2);
5735 if (!SWIG_IsOK(ecode2)) {
5736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5737 }
5738 arg2 = static_cast< int >(val2);
5739 }
5740 {
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = (wxPoint *)new wxPoint(arg1,arg2);
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 PyObject *swig_obj[1] ;
5759
5760 if (!args) SWIG_fail;
5761 swig_obj[0] = args;
5762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5763 if (!SWIG_IsOK(res1)) {
5764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5765 }
5766 arg1 = reinterpret_cast< wxPoint * >(argp1);
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 delete arg1;
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 resultobj = SWIG_Py_Void();
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj = 0;
5783 wxPoint *arg1 = (wxPoint *) 0 ;
5784 PyObject *arg2 = (PyObject *) 0 ;
5785 bool result;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 char * kwnames[] = {
5791 (char *) "self",(char *) "other", NULL
5792 };
5793
5794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5796 if (!SWIG_IsOK(res1)) {
5797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5798 }
5799 arg1 = reinterpret_cast< wxPoint * >(argp1);
5800 arg2 = obj1;
5801 {
5802 result = (bool)wxPoint___eq__(arg1,arg2);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5807 }
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj = 0;
5816 wxPoint *arg1 = (wxPoint *) 0 ;
5817 PyObject *arg2 = (PyObject *) 0 ;
5818 bool result;
5819 void *argp1 = 0 ;
5820 int res1 = 0 ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 char * kwnames[] = {
5824 (char *) "self",(char *) "other", NULL
5825 };
5826
5827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 arg2 = obj1;
5834 {
5835 result = (bool)wxPoint___ne__(arg1,arg2);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5840 }
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = 0;
5849 wxPoint *arg1 = (wxPoint *) 0 ;
5850 wxPoint *arg2 = 0 ;
5851 wxPoint result;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 wxPoint temp2 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "self",(char *) "pt", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5865 }
5866 arg1 = reinterpret_cast< wxPoint * >(argp1);
5867 {
5868 arg2 = &temp2;
5869 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5870 }
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 result = (arg1)->operator +((wxPoint const &)*arg2);
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = 0;
5886 wxPoint *arg1 = (wxPoint *) 0 ;
5887 wxPoint *arg2 = 0 ;
5888 wxPoint result;
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___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5900 if (!SWIG_IsOK(res1)) {
5901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', 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 result = (arg1)->operator -((wxPoint const &)*arg2);
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5915 return resultobj;
5916 fail:
5917 return NULL;
5918 }
5919
5920
5921 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5922 PyObject *resultobj = 0;
5923 wxPoint *arg1 = (wxPoint *) 0 ;
5924 wxPoint *arg2 = 0 ;
5925 wxPoint *result = 0 ;
5926 void *argp1 = 0 ;
5927 int res1 = 0 ;
5928 wxPoint temp2 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "self",(char *) "pt", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5937 if (!SWIG_IsOK(res1)) {
5938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5939 }
5940 arg1 = reinterpret_cast< wxPoint * >(argp1);
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 {
5948 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5949 result = (wxPoint *) &_result_ref;
5950 }
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 wxPoint *arg2 = 0 ;
5965 wxPoint *result = 0 ;
5966 void *argp1 = 0 ;
5967 int res1 = 0 ;
5968 wxPoint temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "self",(char *) "pt", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5977 if (!SWIG_IsOK(res1)) {
5978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5979 }
5980 arg1 = reinterpret_cast< wxPoint * >(argp1);
5981 {
5982 arg2 = &temp2;
5983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5984 }
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 {
5988 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5989 result = (wxPoint *) &_result_ref;
5990 }
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 long arg2 ;
6005 long arg3 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 long val2 ;
6009 int ecode2 = 0 ;
6010 long val3 ;
6011 int ecode3 = 0 ;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 PyObject * obj2 = 0 ;
6015 char * kwnames[] = {
6016 (char *) "self",(char *) "x",(char *) "y", NULL
6017 };
6018
6019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6021 if (!SWIG_IsOK(res1)) {
6022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6023 }
6024 arg1 = reinterpret_cast< wxPoint * >(argp1);
6025 ecode2 = SWIG_AsVal_long(obj1, &val2);
6026 if (!SWIG_IsOK(ecode2)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6028 }
6029 arg2 = static_cast< long >(val2);
6030 ecode3 = SWIG_AsVal_long(obj2, &val3);
6031 if (!SWIG_IsOK(ecode3)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6033 }
6034 arg3 = static_cast< long >(val3);
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 wxPoint_Set(arg1,arg2,arg3);
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_Py_Void();
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 PyObject *result = 0 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 PyObject *swig_obj[1] ;
6055
6056 if (!args) SWIG_fail;
6057 swig_obj[0] = args;
6058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6059 if (!SWIG_IsOK(res1)) {
6060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6061 }
6062 arg1 = reinterpret_cast< wxPoint * >(argp1);
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (PyObject *)wxPoint_Get(arg1);
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 resultobj = result;
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6077 PyObject *obj;
6078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6080 return SWIG_Py_Void();
6081 }
6082
6083 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6084 return SWIG_Python_InitShadowInstance(args);
6085 }
6086
6087 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 int arg1 = (int) 0 ;
6090 int arg2 = (int) 0 ;
6091 int arg3 = (int) 0 ;
6092 int arg4 = (int) 0 ;
6093 wxRect *result = 0 ;
6094 int val1 ;
6095 int ecode1 = 0 ;
6096 int val2 ;
6097 int ecode2 = 0 ;
6098 int val3 ;
6099 int ecode3 = 0 ;
6100 int val4 ;
6101 int ecode4 = 0 ;
6102 PyObject * obj0 = 0 ;
6103 PyObject * obj1 = 0 ;
6104 PyObject * obj2 = 0 ;
6105 PyObject * obj3 = 0 ;
6106 char * kwnames[] = {
6107 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6108 };
6109
6110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6111 if (obj0) {
6112 ecode1 = SWIG_AsVal_int(obj0, &val1);
6113 if (!SWIG_IsOK(ecode1)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6115 }
6116 arg1 = static_cast< int >(val1);
6117 }
6118 if (obj1) {
6119 ecode2 = SWIG_AsVal_int(obj1, &val2);
6120 if (!SWIG_IsOK(ecode2)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6122 }
6123 arg2 = static_cast< int >(val2);
6124 }
6125 if (obj2) {
6126 ecode3 = SWIG_AsVal_int(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6129 }
6130 arg3 = static_cast< int >(val3);
6131 }
6132 if (obj3) {
6133 ecode4 = SWIG_AsVal_int(obj3, &val4);
6134 if (!SWIG_IsOK(ecode4)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6136 }
6137 arg4 = static_cast< int >(val4);
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6153 PyObject *resultobj = 0;
6154 wxPoint *arg1 = 0 ;
6155 wxPoint *arg2 = 0 ;
6156 wxRect *result = 0 ;
6157 wxPoint temp1 ;
6158 wxPoint temp2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "topLeft",(char *) "bottomRight", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxPoint *arg1 = 0 ;
6190 wxSize *arg2 = 0 ;
6191 wxRect *result = 0 ;
6192 wxPoint temp1 ;
6193 wxSize temp2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "pos",(char *) "size", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6201 {
6202 arg1 = &temp1;
6203 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6204 }
6205 {
6206 arg2 = &temp2;
6207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6208 }
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxSize *arg1 = 0 ;
6225 wxRect *result = 0 ;
6226 wxSize temp1 ;
6227 PyObject * obj0 = 0 ;
6228 char * kwnames[] = {
6229 (char *) "size", NULL
6230 };
6231
6232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6233 {
6234 arg1 = &temp1;
6235 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6236 }
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6240 wxPyEndAllowThreads(__tstate);
6241 if (PyErr_Occurred()) SWIG_fail;
6242 }
6243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6244 return resultobj;
6245 fail:
6246 return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6251 PyObject *resultobj = 0;
6252 wxRect *arg1 = (wxRect *) 0 ;
6253 void *argp1 = 0 ;
6254 int res1 = 0 ;
6255 PyObject *swig_obj[1] ;
6256
6257 if (!args) SWIG_fail;
6258 swig_obj[0] = args;
6259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6262 }
6263 arg1 = reinterpret_cast< wxRect * >(argp1);
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 delete arg1;
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_Py_Void();
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6279 PyObject *resultobj = 0;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int result;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 PyObject *swig_obj[1] ;
6285
6286 if (!args) SWIG_fail;
6287 swig_obj[0] = args;
6288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6289 if (!SWIG_IsOK(res1)) {
6290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6291 }
6292 arg1 = reinterpret_cast< wxRect * >(argp1);
6293 {
6294 PyThreadState* __tstate = wxPyBeginAllowThreads();
6295 result = (int)((wxRect const *)arg1)->GetX();
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 resultobj = SWIG_From_int(static_cast< int >(result));
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj = 0;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int arg2 ;
6310 void *argp1 = 0 ;
6311 int res1 = 0 ;
6312 int val2 ;
6313 int ecode2 = 0 ;
6314 PyObject * obj0 = 0 ;
6315 PyObject * obj1 = 0 ;
6316 char * kwnames[] = {
6317 (char *) "self",(char *) "x", NULL
6318 };
6319
6320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6322 if (!SWIG_IsOK(res1)) {
6323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6324 }
6325 arg1 = reinterpret_cast< wxRect * >(argp1);
6326 ecode2 = SWIG_AsVal_int(obj1, &val2);
6327 if (!SWIG_IsOK(ecode2)) {
6328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6329 }
6330 arg2 = static_cast< int >(val2);
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 (arg1)->SetX(arg2);
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_Py_Void();
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6345 PyObject *resultobj = 0;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int result;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 PyObject *swig_obj[1] ;
6351
6352 if (!args) SWIG_fail;
6353 swig_obj[0] = args;
6354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6357 }
6358 arg1 = reinterpret_cast< wxRect * >(argp1);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 result = (int)(arg1)->GetY();
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_From_int(static_cast< int >(result));
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int arg2 ;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 int val2 ;
6379 int ecode2 = 0 ;
6380 PyObject * obj0 = 0 ;
6381 PyObject * obj1 = 0 ;
6382 char * kwnames[] = {
6383 (char *) "self",(char *) "y", NULL
6384 };
6385
6386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6388 if (!SWIG_IsOK(res1)) {
6389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6390 }
6391 arg1 = reinterpret_cast< wxRect * >(argp1);
6392 ecode2 = SWIG_AsVal_int(obj1, &val2);
6393 if (!SWIG_IsOK(ecode2)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6395 }
6396 arg2 = static_cast< int >(val2);
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 (arg1)->SetY(arg2);
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_Py_Void();
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6411 PyObject *resultobj = 0;
6412 wxRect *arg1 = (wxRect *) 0 ;
6413 int result;
6414 void *argp1 = 0 ;
6415 int res1 = 0 ;
6416 PyObject *swig_obj[1] ;
6417
6418 if (!args) SWIG_fail;
6419 swig_obj[0] = args;
6420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6421 if (!SWIG_IsOK(res1)) {
6422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6423 }
6424 arg1 = reinterpret_cast< wxRect * >(argp1);
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 result = (int)((wxRect const *)arg1)->GetWidth();
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 resultobj = SWIG_From_int(static_cast< int >(result));
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj = 0;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 int arg2 ;
6442 void *argp1 = 0 ;
6443 int res1 = 0 ;
6444 int val2 ;
6445 int ecode2 = 0 ;
6446 PyObject * obj0 = 0 ;
6447 PyObject * obj1 = 0 ;
6448 char * kwnames[] = {
6449 (char *) "self",(char *) "w", NULL
6450 };
6451
6452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6454 if (!SWIG_IsOK(res1)) {
6455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6456 }
6457 arg1 = reinterpret_cast< wxRect * >(argp1);
6458 ecode2 = SWIG_AsVal_int(obj1, &val2);
6459 if (!SWIG_IsOK(ecode2)) {
6460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6461 }
6462 arg2 = static_cast< int >(val2);
6463 {
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 (arg1)->SetWidth(arg2);
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_Py_Void();
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int result;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 PyObject *swig_obj[1] ;
6483
6484 if (!args) SWIG_fail;
6485 swig_obj[0] = args;
6486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6487 if (!SWIG_IsOK(res1)) {
6488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6489 }
6490 arg1 = reinterpret_cast< wxRect * >(argp1);
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 result = (int)((wxRect const *)arg1)->GetHeight();
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_From_int(static_cast< int >(result));
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj = 0;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 int arg2 ;
6508 void *argp1 = 0 ;
6509 int res1 = 0 ;
6510 int val2 ;
6511 int ecode2 = 0 ;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char * kwnames[] = {
6515 (char *) "self",(char *) "h", NULL
6516 };
6517
6518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6520 if (!SWIG_IsOK(res1)) {
6521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6522 }
6523 arg1 = reinterpret_cast< wxRect * >(argp1);
6524 ecode2 = SWIG_AsVal_int(obj1, &val2);
6525 if (!SWIG_IsOK(ecode2)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6527 }
6528 arg2 = static_cast< int >(val2);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 (arg1)->SetHeight(arg2);
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_Py_Void();
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543 PyObject *resultobj = 0;
6544 wxRect *arg1 = (wxRect *) 0 ;
6545 wxPoint result;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 PyObject *swig_obj[1] ;
6549
6550 if (!args) SWIG_fail;
6551 swig_obj[0] = args;
6552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = ((wxRect const *)arg1)->GetPosition();
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 wxPoint *arg2 = 0 ;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 wxPoint temp2 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 char * kwnames[] = {
6580 (char *) "self",(char *) "p", NULL
6581 };
6582
6583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 arg2 = &temp2;
6591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetPosition((wxPoint const &)*arg2);
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_Py_Void();
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxSize result;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 PyObject *swig_obj[1] ;
6613
6614 if (!args) SWIG_fail;
6615 swig_obj[0] = args;
6616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6619 }
6620 arg1 = reinterpret_cast< wxRect * >(argp1);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = ((wxRect const *)arg1)->GetSize();
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 wxSize *arg2 = 0 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 wxSize temp2 ;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char * kwnames[] = {
6644 (char *) "self",(char *) "s", NULL
6645 };
6646
6647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 arg2 = &temp2;
6655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->SetSize((wxSize const &)*arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 bool result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)((wxRect const *)arg1)->IsEmpty();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 wxRect *arg1 = (wxRect *) 0 ;
6703 wxPoint result;
6704 void *argp1 = 0 ;
6705 int res1 = 0 ;
6706 PyObject *swig_obj[1] ;
6707
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = ((wxRect const *)arg1)->GetTopLeft();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj = 0;
6730 wxRect *arg1 = (wxRect *) 0 ;
6731 wxPoint *arg2 = 0 ;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 wxPoint temp2 ;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 char * kwnames[] = {
6738 (char *) "self",(char *) "p", NULL
6739 };
6740
6741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 arg2 = &temp2;
6749 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6750 }
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 wxRect *arg1 = (wxRect *) 0 ;
6767 wxPoint result;
6768 void *argp1 = 0 ;
6769 int res1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 if (!args) SWIG_fail;
6773 swig_obj[0] = args;
6774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6775 if (!SWIG_IsOK(res1)) {
6776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6777 }
6778 arg1 = reinterpret_cast< wxRect * >(argp1);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = ((wxRect const *)arg1)->GetBottomRight();
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 wxPoint *arg2 = 0 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 wxPoint temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char * kwnames[] = {
6802 (char *) "self",(char *) "p", NULL
6803 };
6804
6805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 arg2 = &temp2;
6813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6814 }
6815 {
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_Py_Void();
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 int result;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 result = (int)((wxRect const *)arg1)->GetLeft();
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_From_int(static_cast< int >(result));
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6857 PyObject *resultobj = 0;
6858 wxRect *arg1 = (wxRect *) 0 ;
6859 int result;
6860 void *argp1 = 0 ;
6861 int res1 = 0 ;
6862 PyObject *swig_obj[1] ;
6863
6864 if (!args) SWIG_fail;
6865 swig_obj[0] = args;
6866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6869 }
6870 arg1 = reinterpret_cast< wxRect * >(argp1);
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 result = (int)((wxRect const *)arg1)->GetTop();
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_From_int(static_cast< int >(result));
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 int result;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 PyObject *swig_obj[1] ;
6891
6892 if (!args) SWIG_fail;
6893 swig_obj[0] = args;
6894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6895 if (!SWIG_IsOK(res1)) {
6896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6897 }
6898 arg1 = reinterpret_cast< wxRect * >(argp1);
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 result = (int)((wxRect const *)arg1)->GetBottom();
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_From_int(static_cast< int >(result));
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxRect *arg1 = (wxRect *) 0 ;
6915 int result;
6916 void *argp1 = 0 ;
6917 int res1 = 0 ;
6918 PyObject *swig_obj[1] ;
6919
6920 if (!args) SWIG_fail;
6921 swig_obj[0] = args;
6922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6925 }
6926 arg1 = reinterpret_cast< wxRect * >(argp1);
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 result = (int)((wxRect const *)arg1)->GetRight();
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_From_int(static_cast< int >(result));
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj = 0;
6942 wxRect *arg1 = (wxRect *) 0 ;
6943 int arg2 ;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 int val2 ;
6947 int ecode2 = 0 ;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 char * kwnames[] = {
6951 (char *) "self",(char *) "left", NULL
6952 };
6953
6954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6956 if (!SWIG_IsOK(res1)) {
6957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6958 }
6959 arg1 = reinterpret_cast< wxRect * >(argp1);
6960 ecode2 = SWIG_AsVal_int(obj1, &val2);
6961 if (!SWIG_IsOK(ecode2)) {
6962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6963 }
6964 arg2 = static_cast< int >(val2);
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 (arg1)->SetLeft(arg2);
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj = 0;
6980 wxRect *arg1 = (wxRect *) 0 ;
6981 int arg2 ;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 int val2 ;
6985 int ecode2 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 char * kwnames[] = {
6989 (char *) "self",(char *) "right", NULL
6990 };
6991
6992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6994 if (!SWIG_IsOK(res1)) {
6995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6996 }
6997 arg1 = reinterpret_cast< wxRect * >(argp1);
6998 ecode2 = SWIG_AsVal_int(obj1, &val2);
6999 if (!SWIG_IsOK(ecode2)) {
7000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7001 }
7002 arg2 = static_cast< int >(val2);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 (arg1)->SetRight(arg2);
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_Py_Void();
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxRect *arg1 = (wxRect *) 0 ;
7019 int arg2 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 int val2 ;
7023 int ecode2 = 0 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "self",(char *) "top", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7034 }
7035 arg1 = reinterpret_cast< wxRect * >(argp1);
7036 ecode2 = SWIG_AsVal_int(obj1, &val2);
7037 if (!SWIG_IsOK(ecode2)) {
7038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7039 }
7040 arg2 = static_cast< int >(val2);
7041 {
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 (arg1)->SetTop(arg2);
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_Py_Void();
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj = 0;
7056 wxRect *arg1 = (wxRect *) 0 ;
7057 int arg2 ;
7058 void *argp1 = 0 ;
7059 int res1 = 0 ;
7060 int val2 ;
7061 int ecode2 = 0 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "bottom", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7070 if (!SWIG_IsOK(res1)) {
7071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7072 }
7073 arg1 = reinterpret_cast< wxRect * >(argp1);
7074 ecode2 = SWIG_AsVal_int(obj1, &val2);
7075 if (!SWIG_IsOK(ecode2)) {
7076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7077 }
7078 arg2 = static_cast< int >(val2);
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 (arg1)->SetBottom(arg2);
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_Py_Void();
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7093 PyObject *resultobj = 0;
7094 wxRect *arg1 = (wxRect *) 0 ;
7095 int arg2 ;
7096 int arg3 ;
7097 wxRect *result = 0 ;
7098 void *argp1 = 0 ;
7099 int res1 = 0 ;
7100 int val2 ;
7101 int ecode2 = 0 ;
7102 int val3 ;
7103 int ecode3 = 0 ;
7104 PyObject * obj0 = 0 ;
7105 PyObject * obj1 = 0 ;
7106 PyObject * obj2 = 0 ;
7107 char * kwnames[] = {
7108 (char *) "self",(char *) "dx",(char *) "dy", NULL
7109 };
7110
7111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 ecode2 = SWIG_AsVal_int(obj1, &val2);
7118 if (!SWIG_IsOK(ecode2)) {
7119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7120 }
7121 arg2 = static_cast< int >(val2);
7122 ecode3 = SWIG_AsVal_int(obj2, &val3);
7123 if (!SWIG_IsOK(ecode3)) {
7124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7125 }
7126 arg3 = static_cast< int >(val3);
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 {
7130 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7131 result = (wxRect *) &_result_ref;
7132 }
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 int arg2 ;
7147 int arg3 ;
7148 wxRect *result = 0 ;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 int val2 ;
7152 int ecode2 = 0 ;
7153 int val3 ;
7154 int ecode3 = 0 ;
7155 PyObject * obj0 = 0 ;
7156 PyObject * obj1 = 0 ;
7157 PyObject * obj2 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "dx",(char *) "dy", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 ecode3 = SWIG_AsVal_int(obj2, &val3);
7174 if (!SWIG_IsOK(ecode3)) {
7175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7176 }
7177 arg3 = static_cast< int >(val3);
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 {
7181 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7182 result = (wxRect *) &_result_ref;
7183 }
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj = 0;
7196 wxRect *arg1 = (wxRect *) 0 ;
7197 int arg2 ;
7198 int arg3 ;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 int val2 ;
7202 int ecode2 = 0 ;
7203 int val3 ;
7204 int ecode3 = 0 ;
7205 PyObject * obj0 = 0 ;
7206 PyObject * obj1 = 0 ;
7207 PyObject * obj2 = 0 ;
7208 char * kwnames[] = {
7209 (char *) "self",(char *) "dx",(char *) "dy", NULL
7210 };
7211
7212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7216 }
7217 arg1 = reinterpret_cast< wxRect * >(argp1);
7218 ecode2 = SWIG_AsVal_int(obj1, &val2);
7219 if (!SWIG_IsOK(ecode2)) {
7220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7221 }
7222 arg2 = static_cast< int >(val2);
7223 ecode3 = SWIG_AsVal_int(obj2, &val3);
7224 if (!SWIG_IsOK(ecode3)) {
7225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7226 }
7227 arg3 = static_cast< int >(val3);
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 (arg1)->Offset(arg2,arg3);
7231 wxPyEndAllowThreads(__tstate);
7232 if (PyErr_Occurred()) SWIG_fail;
7233 }
7234 resultobj = SWIG_Py_Void();
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7242 PyObject *resultobj = 0;
7243 wxRect *arg1 = (wxRect *) 0 ;
7244 wxPoint *arg2 = 0 ;
7245 void *argp1 = 0 ;
7246 int res1 = 0 ;
7247 wxPoint temp2 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char * kwnames[] = {
7251 (char *) "self",(char *) "pt", NULL
7252 };
7253
7254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7258 }
7259 arg1 = reinterpret_cast< wxRect * >(argp1);
7260 {
7261 arg2 = &temp2;
7262 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7263 }
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 (arg1)->Offset((wxPoint const &)*arg2);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_Py_Void();
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = 0;
7279 wxRect *arg1 = (wxRect *) 0 ;
7280 wxRect *arg2 = 0 ;
7281 wxRect result;
7282 void *argp1 = 0 ;
7283 int res1 = 0 ;
7284 wxRect temp2 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "rect", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 {
7298 arg2 = &temp2;
7299 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7300 }
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 result = (arg1)->Intersect((wxRect const &)*arg2);
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj = 0;
7316 wxRect *arg1 = (wxRect *) 0 ;
7317 wxRect *arg2 = 0 ;
7318 wxRect result;
7319 void *argp1 = 0 ;
7320 int res1 = 0 ;
7321 wxRect temp2 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 char * kwnames[] = {
7325 (char *) "self",(char *) "rect", NULL
7326 };
7327
7328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7330 if (!SWIG_IsOK(res1)) {
7331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7332 }
7333 arg1 = reinterpret_cast< wxRect * >(argp1);
7334 {
7335 arg2 = &temp2;
7336 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7337 }
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (arg1)->Union((wxRect const &)*arg2);
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 wxRect *arg2 = 0 ;
7355 wxRect result;
7356 void *argp1 = 0 ;
7357 int res1 = 0 ;
7358 wxRect temp2 ;
7359 PyObject * obj0 = 0 ;
7360 PyObject * obj1 = 0 ;
7361 char * kwnames[] = {
7362 (char *) "self",(char *) "rect", NULL
7363 };
7364
7365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7367 if (!SWIG_IsOK(res1)) {
7368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7369 }
7370 arg1 = reinterpret_cast< wxRect * >(argp1);
7371 {
7372 arg2 = &temp2;
7373 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7374 }
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj = 0;
7390 wxRect *arg1 = (wxRect *) 0 ;
7391 wxRect *arg2 = 0 ;
7392 wxRect *result = 0 ;
7393 void *argp1 = 0 ;
7394 int res1 = 0 ;
7395 wxRect temp2 ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char * kwnames[] = {
7399 (char *) "self",(char *) "rect", NULL
7400 };
7401
7402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7404 if (!SWIG_IsOK(res1)) {
7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7406 }
7407 arg1 = reinterpret_cast< wxRect * >(argp1);
7408 {
7409 arg2 = &temp2;
7410 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7411 }
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 {
7415 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7416 result = (wxRect *) &_result_ref;
7417 }
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj = 0;
7430 wxRect *arg1 = (wxRect *) 0 ;
7431 PyObject *arg2 = (PyObject *) 0 ;
7432 bool result;
7433 void *argp1 = 0 ;
7434 int res1 = 0 ;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 char * kwnames[] = {
7438 (char *) "self",(char *) "other", NULL
7439 };
7440
7441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7443 if (!SWIG_IsOK(res1)) {
7444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7445 }
7446 arg1 = reinterpret_cast< wxRect * >(argp1);
7447 arg2 = obj1;
7448 {
7449 result = (bool)wxRect___eq__(arg1,arg2);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 {
7453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7454 }
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj = 0;
7463 wxRect *arg1 = (wxRect *) 0 ;
7464 PyObject *arg2 = (PyObject *) 0 ;
7465 bool result;
7466 void *argp1 = 0 ;
7467 int res1 = 0 ;
7468 PyObject * obj0 = 0 ;
7469 PyObject * obj1 = 0 ;
7470 char * kwnames[] = {
7471 (char *) "self",(char *) "other", NULL
7472 };
7473
7474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7478 }
7479 arg1 = reinterpret_cast< wxRect * >(argp1);
7480 arg2 = obj1;
7481 {
7482 result = (bool)wxRect___ne__(arg1,arg2);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj = 0;
7496 wxRect *arg1 = (wxRect *) 0 ;
7497 int arg2 ;
7498 int arg3 ;
7499 bool result;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 int val2 ;
7503 int ecode2 = 0 ;
7504 int val3 ;
7505 int ecode3 = 0 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 PyObject * obj2 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "x",(char *) "y", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7517 }
7518 arg1 = reinterpret_cast< wxRect * >(argp1);
7519 ecode2 = SWIG_AsVal_int(obj1, &val2);
7520 if (!SWIG_IsOK(ecode2)) {
7521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7522 }
7523 arg2 = static_cast< int >(val2);
7524 ecode3 = SWIG_AsVal_int(obj2, &val3);
7525 if (!SWIG_IsOK(ecode3)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7527 }
7528 arg3 = static_cast< int >(val3);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 {
7536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7537 }
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxRect *arg1 = (wxRect *) 0 ;
7547 wxPoint *arg2 = 0 ;
7548 bool result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 wxPoint temp2 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char * kwnames[] = {
7555 (char *) "self",(char *) "pt", NULL
7556 };
7557
7558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7560 if (!SWIG_IsOK(res1)) {
7561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7562 }
7563 arg1 = reinterpret_cast< wxRect * >(argp1);
7564 {
7565 arg2 = &temp2;
7566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7567 }
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7576 }
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj = 0;
7585 wxRect *arg1 = (wxRect *) 0 ;
7586 wxRect *arg2 = 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 wxRect temp2 ;
7591 PyObject * obj0 = 0 ;
7592 PyObject * obj1 = 0 ;
7593 char * kwnames[] = {
7594 (char *) "self",(char *) "rect", NULL
7595 };
7596
7597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7601 }
7602 arg1 = reinterpret_cast< wxRect * >(argp1);
7603 {
7604 arg2 = &temp2;
7605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7606 }
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 wxRect *arg2 = 0 ;
7626 bool result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 wxRect temp2 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char * kwnames[] = {
7633 (char *) "self",(char *) "rect", NULL
7634 };
7635
7636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7640 }
7641 arg1 = reinterpret_cast< wxRect * >(argp1);
7642 {
7643 arg2 = &temp2;
7644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7645 }
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 {
7653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7654 }
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj = 0;
7663 wxRect *arg1 = (wxRect *) 0 ;
7664 wxRect *arg2 = 0 ;
7665 int arg3 = (int) wxBOTH ;
7666 wxRect result;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 wxRect temp2 ;
7670 int val3 ;
7671 int ecode3 = 0 ;
7672 PyObject * obj0 = 0 ;
7673 PyObject * obj1 = 0 ;
7674 PyObject * obj2 = 0 ;
7675 char * kwnames[] = {
7676 (char *) "self",(char *) "r",(char *) "dir", NULL
7677 };
7678
7679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7681 if (!SWIG_IsOK(res1)) {
7682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7683 }
7684 arg1 = reinterpret_cast< wxRect * >(argp1);
7685 {
7686 arg2 = &temp2;
7687 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7688 }
7689 if (obj2) {
7690 ecode3 = SWIG_AsVal_int(obj2, &val3);
7691 if (!SWIG_IsOK(ecode3)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7693 }
7694 arg3 = static_cast< int >(val3);
7695 }
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7710 PyObject *resultobj = 0;
7711 wxRect *arg1 = (wxRect *) 0 ;
7712 int arg2 ;
7713 void *argp1 = 0 ;
7714 int res1 = 0 ;
7715 int val2 ;
7716 int ecode2 = 0 ;
7717 PyObject *swig_obj[2] ;
7718
7719 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7728 }
7729 arg2 = static_cast< int >(val2);
7730 if (arg1) (arg1)->x = arg2;
7731
7732 resultobj = SWIG_Py_Void();
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740 PyObject *resultobj = 0;
7741 wxRect *arg1 = (wxRect *) 0 ;
7742 int result;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 PyObject *swig_obj[1] ;
7746
7747 if (!args) SWIG_fail;
7748 swig_obj[0] = args;
7749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 result = (int) ((arg1)->x);
7755 resultobj = SWIG_From_int(static_cast< int >(result));
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763 PyObject *resultobj = 0;
7764 wxRect *arg1 = (wxRect *) 0 ;
7765 int arg2 ;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 int val2 ;
7769 int ecode2 = 0 ;
7770 PyObject *swig_obj[2] ;
7771
7772 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7776 }
7777 arg1 = reinterpret_cast< wxRect * >(argp1);
7778 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7781 }
7782 arg2 = static_cast< int >(val2);
7783 if (arg1) (arg1)->y = arg2;
7784
7785 resultobj = SWIG_Py_Void();
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7793 PyObject *resultobj = 0;
7794 wxRect *arg1 = (wxRect *) 0 ;
7795 int result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 PyObject *swig_obj[1] ;
7799
7800 if (!args) SWIG_fail;
7801 swig_obj[0] = args;
7802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7803 if (!SWIG_IsOK(res1)) {
7804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7805 }
7806 arg1 = reinterpret_cast< wxRect * >(argp1);
7807 result = (int) ((arg1)->y);
7808 resultobj = SWIG_From_int(static_cast< int >(result));
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7816 PyObject *resultobj = 0;
7817 wxRect *arg1 = (wxRect *) 0 ;
7818 int arg2 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 int val2 ;
7822 int ecode2 = 0 ;
7823 PyObject *swig_obj[2] ;
7824
7825 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7829 }
7830 arg1 = reinterpret_cast< wxRect * >(argp1);
7831 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7832 if (!SWIG_IsOK(ecode2)) {
7833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7834 }
7835 arg2 = static_cast< int >(val2);
7836 if (arg1) (arg1)->width = arg2;
7837
7838 resultobj = SWIG_Py_Void();
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 int result;
7849 void *argp1 = 0 ;
7850 int res1 = 0 ;
7851 PyObject *swig_obj[1] ;
7852
7853 if (!args) SWIG_fail;
7854 swig_obj[0] = args;
7855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7856 if (!SWIG_IsOK(res1)) {
7857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7858 }
7859 arg1 = reinterpret_cast< wxRect * >(argp1);
7860 result = (int) ((arg1)->width);
7861 resultobj = SWIG_From_int(static_cast< int >(result));
7862 return resultobj;
7863 fail:
7864 return NULL;
7865 }
7866
7867
7868 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7869 PyObject *resultobj = 0;
7870 wxRect *arg1 = (wxRect *) 0 ;
7871 int arg2 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 int val2 ;
7875 int ecode2 = 0 ;
7876 PyObject *swig_obj[2] ;
7877
7878 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7882 }
7883 arg1 = reinterpret_cast< wxRect * >(argp1);
7884 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7887 }
7888 arg2 = static_cast< int >(val2);
7889 if (arg1) (arg1)->height = arg2;
7890
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 int result;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 PyObject *swig_obj[1] ;
7905
7906 if (!args) SWIG_fail;
7907 swig_obj[0] = args;
7908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7909 if (!SWIG_IsOK(res1)) {
7910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7911 }
7912 arg1 = reinterpret_cast< wxRect * >(argp1);
7913 result = (int) ((arg1)->height);
7914 resultobj = SWIG_From_int(static_cast< int >(result));
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj = 0;
7923 wxRect *arg1 = (wxRect *) 0 ;
7924 int arg2 = (int) 0 ;
7925 int arg3 = (int) 0 ;
7926 int arg4 = (int) 0 ;
7927 int arg5 = (int) 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 int val2 ;
7931 int ecode2 = 0 ;
7932 int val3 ;
7933 int ecode3 = 0 ;
7934 int val4 ;
7935 int ecode4 = 0 ;
7936 int val5 ;
7937 int ecode5 = 0 ;
7938 PyObject * obj0 = 0 ;
7939 PyObject * obj1 = 0 ;
7940 PyObject * obj2 = 0 ;
7941 PyObject * obj3 = 0 ;
7942 PyObject * obj4 = 0 ;
7943 char * kwnames[] = {
7944 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7945 };
7946
7947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7949 if (!SWIG_IsOK(res1)) {
7950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7951 }
7952 arg1 = reinterpret_cast< wxRect * >(argp1);
7953 if (obj1) {
7954 ecode2 = SWIG_AsVal_int(obj1, &val2);
7955 if (!SWIG_IsOK(ecode2)) {
7956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7957 }
7958 arg2 = static_cast< int >(val2);
7959 }
7960 if (obj2) {
7961 ecode3 = SWIG_AsVal_int(obj2, &val3);
7962 if (!SWIG_IsOK(ecode3)) {
7963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7964 }
7965 arg3 = static_cast< int >(val3);
7966 }
7967 if (obj3) {
7968 ecode4 = SWIG_AsVal_int(obj3, &val4);
7969 if (!SWIG_IsOK(ecode4)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7971 }
7972 arg4 = static_cast< int >(val4);
7973 }
7974 if (obj4) {
7975 ecode5 = SWIG_AsVal_int(obj4, &val5);
7976 if (!SWIG_IsOK(ecode5)) {
7977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7978 }
7979 arg5 = static_cast< int >(val5);
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_Py_Void();
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7995 PyObject *resultobj = 0;
7996 wxRect *arg1 = (wxRect *) 0 ;
7997 PyObject *result = 0 ;
7998 void *argp1 = 0 ;
7999 int res1 = 0 ;
8000 PyObject *swig_obj[1] ;
8001
8002 if (!args) SWIG_fail;
8003 swig_obj[0] = args;
8004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8005 if (!SWIG_IsOK(res1)) {
8006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8007 }
8008 arg1 = reinterpret_cast< wxRect * >(argp1);
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (PyObject *)wxRect_Get(arg1);
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = result;
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *obj;
8024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8025 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8026 return SWIG_Py_Void();
8027 }
8028
8029 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8030 return SWIG_Python_InitShadowInstance(args);
8031 }
8032
8033 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxRect *arg1 = (wxRect *) 0 ;
8036 wxRect *arg2 = (wxRect *) 0 ;
8037 PyObject *result = 0 ;
8038 void *argp1 = 0 ;
8039 int res1 = 0 ;
8040 void *argp2 = 0 ;
8041 int res2 = 0 ;
8042 PyObject * obj0 = 0 ;
8043 PyObject * obj1 = 0 ;
8044 char * kwnames[] = {
8045 (char *) "r1",(char *) "r2", NULL
8046 };
8047
8048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8050 if (!SWIG_IsOK(res1)) {
8051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8052 }
8053 arg1 = reinterpret_cast< wxRect * >(argp1);
8054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8055 if (!SWIG_IsOK(res2)) {
8056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8057 }
8058 arg2 = reinterpret_cast< wxRect * >(argp2);
8059 {
8060 if (!wxPyCheckForApp()) SWIG_fail;
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 result = (PyObject *)wxIntersectRect(arg1,arg2);
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = result;
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = 0;
8075 double arg1 = (double) 0.0 ;
8076 double arg2 = (double) 0.0 ;
8077 wxPoint2D *result = 0 ;
8078 double val1 ;
8079 int ecode1 = 0 ;
8080 double val2 ;
8081 int ecode2 = 0 ;
8082 PyObject * obj0 = 0 ;
8083 PyObject * obj1 = 0 ;
8084 char * kwnames[] = {
8085 (char *) "x",(char *) "y", NULL
8086 };
8087
8088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8089 if (obj0) {
8090 ecode1 = SWIG_AsVal_double(obj0, &val1);
8091 if (!SWIG_IsOK(ecode1)) {
8092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8093 }
8094 arg1 = static_cast< double >(val1);
8095 }
8096 if (obj1) {
8097 ecode2 = SWIG_AsVal_double(obj1, &val2);
8098 if (!SWIG_IsOK(ecode2)) {
8099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8100 }
8101 arg2 = static_cast< double >(val2);
8102 }
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj = 0;
8118 wxPoint2D *arg1 = 0 ;
8119 wxPoint2D *result = 0 ;
8120 wxPoint2D temp1 ;
8121 PyObject * obj0 = 0 ;
8122 char * kwnames[] = {
8123 (char *) "pt", NULL
8124 };
8125
8126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8127 {
8128 arg1 = &temp1;
8129 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8130 }
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj = 0;
8146 wxPoint *arg1 = 0 ;
8147 wxPoint2D *result = 0 ;
8148 wxPoint temp1 ;
8149 PyObject * obj0 = 0 ;
8150 char * kwnames[] = {
8151 (char *) "pt", NULL
8152 };
8153
8154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8155 {
8156 arg1 = &temp1;
8157 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8158 }
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *resultobj = 0;
8174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8175 int *arg2 = (int *) 0 ;
8176 int *arg3 = (int *) 0 ;
8177 void *argp1 = 0 ;
8178 int res1 = 0 ;
8179 int temp2 ;
8180 int res2 = SWIG_TMPOBJ ;
8181 int temp3 ;
8182 int res3 = SWIG_TMPOBJ ;
8183 PyObject *swig_obj[1] ;
8184
8185 arg2 = &temp2;
8186 arg3 = &temp3;
8187 if (!args) SWIG_fail;
8188 swig_obj[0] = args;
8189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8190 if (!SWIG_IsOK(res1)) {
8191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8192 }
8193 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_Py_Void();
8201 if (SWIG_IsTmpObj(res2)) {
8202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8203 } else {
8204 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8206 }
8207 if (SWIG_IsTmpObj(res3)) {
8208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8209 } else {
8210 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8220 PyObject *resultobj = 0;
8221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8222 int *arg2 = (int *) 0 ;
8223 int *arg3 = (int *) 0 ;
8224 void *argp1 = 0 ;
8225 int res1 = 0 ;
8226 int temp2 ;
8227 int res2 = SWIG_TMPOBJ ;
8228 int temp3 ;
8229 int res3 = SWIG_TMPOBJ ;
8230 PyObject *swig_obj[1] ;
8231
8232 arg2 = &temp2;
8233 arg3 = &temp3;
8234 if (!args) SWIG_fail;
8235 swig_obj[0] = args;
8236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8237 if (!SWIG_IsOK(res1)) {
8238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8239 }
8240 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 resultobj = SWIG_Py_Void();
8248 if (SWIG_IsTmpObj(res2)) {
8249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8250 } else {
8251 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8253 }
8254 if (SWIG_IsTmpObj(res3)) {
8255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8256 } else {
8257 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8259 }
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8267 PyObject *resultobj = 0;
8268 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8269 double result;
8270 void *argp1 = 0 ;
8271 int res1 = 0 ;
8272 PyObject *swig_obj[1] ;
8273
8274 if (!args) SWIG_fail;
8275 swig_obj[0] = args;
8276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8277 if (!SWIG_IsOK(res1)) {
8278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8279 }
8280 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = SWIG_From_double(static_cast< double >(result));
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8295 PyObject *resultobj = 0;
8296 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8297 double result;
8298 void *argp1 = 0 ;
8299 int res1 = 0 ;
8300 PyObject *swig_obj[1] ;
8301
8302 if (!args) SWIG_fail;
8303 swig_obj[0] = args;
8304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8305 if (!SWIG_IsOK(res1)) {
8306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8307 }
8308 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8312 wxPyEndAllowThreads(__tstate);
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 resultobj = SWIG_From_double(static_cast< double >(result));
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj = 0;
8324 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8325 double arg2 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 double val2 ;
8329 int ecode2 = 0 ;
8330 PyObject * obj0 = 0 ;
8331 PyObject * obj1 = 0 ;
8332 char * kwnames[] = {
8333 (char *) "self",(char *) "length", NULL
8334 };
8335
8336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8338 if (!SWIG_IsOK(res1)) {
8339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8340 }
8341 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8342 ecode2 = SWIG_AsVal_double(obj1, &val2);
8343 if (!SWIG_IsOK(ecode2)) {
8344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8345 }
8346 arg2 = static_cast< double >(val2);
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 (arg1)->SetVectorLength(arg2);
8350 wxPyEndAllowThreads(__tstate);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_Py_Void();
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8363 double arg2 ;
8364 void *argp1 = 0 ;
8365 int res1 = 0 ;
8366 double val2 ;
8367 int ecode2 = 0 ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 char * kwnames[] = {
8371 (char *) "self",(char *) "degrees", NULL
8372 };
8373
8374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8376 if (!SWIG_IsOK(res1)) {
8377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8378 }
8379 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8380 ecode2 = SWIG_AsVal_double(obj1, &val2);
8381 if (!SWIG_IsOK(ecode2)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8383 }
8384 arg2 = static_cast< double >(val2);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 (arg1)->SetVectorAngle(arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8401 wxPoint2D *arg2 = 0 ;
8402 double result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 wxPoint2D temp2 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 char * kwnames[] = {
8409 (char *) "self",(char *) "pt", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8416 }
8417 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8418 {
8419 arg2 = &temp2;
8420 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8421 }
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_From_double(static_cast< double >(result));
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 wxPoint2D *arg2 = 0 ;
8439 double result;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 wxPoint2D temp2 ;
8443 PyObject * obj0 = 0 ;
8444 PyObject * obj1 = 0 ;
8445 char * kwnames[] = {
8446 (char *) "self",(char *) "pt", NULL
8447 };
8448
8449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8453 }
8454 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8455 {
8456 arg2 = &temp2;
8457 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_From_double(static_cast< double >(result));
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 wxPoint2D *arg2 = 0 ;
8476 double result;
8477 void *argp1 = 0 ;
8478 int res1 = 0 ;
8479 wxPoint2D temp2 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 char * kwnames[] = {
8483 (char *) "self",(char *) "vec", NULL
8484 };
8485
8486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 {
8493 arg2 = &temp2;
8494 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8495 }
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 resultobj = SWIG_From_double(static_cast< double >(result));
8503 return resultobj;
8504 fail:
8505 return NULL;
8506 }
8507
8508
8509 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj = 0;
8511 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8512 wxPoint2D *arg2 = 0 ;
8513 double result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 wxPoint2D temp2 ;
8517 PyObject * obj0 = 0 ;
8518 PyObject * obj1 = 0 ;
8519 char * kwnames[] = {
8520 (char *) "self",(char *) "vec", NULL
8521 };
8522
8523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8527 }
8528 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8529 {
8530 arg2 = &temp2;
8531 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_From_double(static_cast< double >(result));
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8549 wxPoint2D result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8559 }
8560 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (arg1)->operator -();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 wxPoint2D *arg2 = 0 ;
8578 wxPoint2D *result = 0 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 wxPoint2D temp2 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "pt", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 {
8595 arg2 = &temp2;
8596 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 {
8601 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8602 result = (wxPoint2D *) &_result_ref;
8603 }
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 wxPoint2D *arg2 = 0 ;
8618 wxPoint2D *result = 0 ;
8619 void *argp1 = 0 ;
8620 int res1 = 0 ;
8621 wxPoint2D temp2 ;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 char * kwnames[] = {
8625 (char *) "self",(char *) "pt", NULL
8626 };
8627
8628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8632 }
8633 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8634 {
8635 arg2 = &temp2;
8636 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8637 }
8638 {
8639 PyThreadState* __tstate = wxPyBeginAllowThreads();
8640 {
8641 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8642 result = (wxPoint2D *) &_result_ref;
8643 }
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj = 0;
8656 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8657 wxPoint2D *arg2 = 0 ;
8658 wxPoint2D *result = 0 ;
8659 void *argp1 = 0 ;
8660 int res1 = 0 ;
8661 wxPoint2D temp2 ;
8662 PyObject * obj0 = 0 ;
8663 PyObject * obj1 = 0 ;
8664 char * kwnames[] = {
8665 (char *) "self",(char *) "pt", NULL
8666 };
8667
8668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8670 if (!SWIG_IsOK(res1)) {
8671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8672 }
8673 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8674 {
8675 arg2 = &temp2;
8676 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8677 }
8678 {
8679 PyThreadState* __tstate = wxPyBeginAllowThreads();
8680 {
8681 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8682 result = (wxPoint2D *) &_result_ref;
8683 }
8684 wxPyEndAllowThreads(__tstate);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj = 0;
8696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8697 wxPoint2D *arg2 = 0 ;
8698 wxPoint2D *result = 0 ;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 wxPoint2D temp2 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 char * kwnames[] = {
8705 (char *) "self",(char *) "pt", NULL
8706 };
8707
8708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 {
8715 arg2 = &temp2;
8716 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8717 }
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 {
8721 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8722 result = (wxPoint2D *) &_result_ref;
8723 }
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj = 0;
8736 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8737 PyObject *arg2 = (PyObject *) 0 ;
8738 bool result;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 char * kwnames[] = {
8744 (char *) "self",(char *) "other", NULL
8745 };
8746
8747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8749 if (!SWIG_IsOK(res1)) {
8750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8751 }
8752 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8753 arg2 = obj1;
8754 {
8755 result = (bool)wxPoint2D___eq__(arg1,arg2);
8756 if (PyErr_Occurred()) SWIG_fail;
8757 }
8758 {
8759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8760 }
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 PyObject *arg2 = (PyObject *) 0 ;
8771 bool result;
8772 void *argp1 = 0 ;
8773 int res1 = 0 ;
8774 PyObject * obj0 = 0 ;
8775 PyObject * obj1 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "other", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 arg2 = obj1;
8787 {
8788 result = (bool)wxPoint2D___ne__(arg1,arg2);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8793 }
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8801 PyObject *resultobj = 0;
8802 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8803 double arg2 ;
8804 void *argp1 = 0 ;
8805 int res1 = 0 ;
8806 double val2 ;
8807 int ecode2 = 0 ;
8808 PyObject *swig_obj[2] ;
8809
8810 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8814 }
8815 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8816 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8817 if (!SWIG_IsOK(ecode2)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8819 }
8820 arg2 = static_cast< double >(val2);
8821 if (arg1) (arg1)->m_x = arg2;
8822
8823 resultobj = SWIG_Py_Void();
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8831 PyObject *resultobj = 0;
8832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8833 double result;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 PyObject *swig_obj[1] ;
8837
8838 if (!args) SWIG_fail;
8839 swig_obj[0] = args;
8840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8843 }
8844 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8845 result = (double) ((arg1)->m_x);
8846 resultobj = SWIG_From_double(static_cast< double >(result));
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8854 PyObject *resultobj = 0;
8855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8856 double arg2 ;
8857 void *argp1 = 0 ;
8858 int res1 = 0 ;
8859 double val2 ;
8860 int ecode2 = 0 ;
8861 PyObject *swig_obj[2] ;
8862
8863 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8867 }
8868 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8869 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8872 }
8873 arg2 = static_cast< double >(val2);
8874 if (arg1) (arg1)->m_y = arg2;
8875
8876 resultobj = SWIG_Py_Void();
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8884 PyObject *resultobj = 0;
8885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8886 double result;
8887 void *argp1 = 0 ;
8888 int res1 = 0 ;
8889 PyObject *swig_obj[1] ;
8890
8891 if (!args) SWIG_fail;
8892 swig_obj[0] = args;
8893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8894 if (!SWIG_IsOK(res1)) {
8895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8896 }
8897 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8898 result = (double) ((arg1)->m_y);
8899 resultobj = SWIG_From_double(static_cast< double >(result));
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 double arg2 = (double) 0 ;
8910 double arg3 = (double) 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 double val2 ;
8914 int ecode2 = 0 ;
8915 double val3 ;
8916 int ecode3 = 0 ;
8917 PyObject * obj0 = 0 ;
8918 PyObject * obj1 = 0 ;
8919 PyObject * obj2 = 0 ;
8920 char * kwnames[] = {
8921 (char *) "self",(char *) "x",(char *) "y", NULL
8922 };
8923
8924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8926 if (!SWIG_IsOK(res1)) {
8927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8928 }
8929 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8930 if (obj1) {
8931 ecode2 = SWIG_AsVal_double(obj1, &val2);
8932 if (!SWIG_IsOK(ecode2)) {
8933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8934 }
8935 arg2 = static_cast< double >(val2);
8936 }
8937 if (obj2) {
8938 ecode3 = SWIG_AsVal_double(obj2, &val3);
8939 if (!SWIG_IsOK(ecode3)) {
8940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8941 }
8942 arg3 = static_cast< double >(val3);
8943 }
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 wxPoint2D_Set(arg1,arg2,arg3);
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 resultobj = SWIG_Py_Void();
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8958 PyObject *resultobj = 0;
8959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8960 PyObject *result = 0 ;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject *swig_obj[1] ;
8964
8965 if (!args) SWIG_fail;
8966 swig_obj[0] = args;
8967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8970 }
8971 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 result = (PyObject *)wxPoint2D_Get(arg1);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = result;
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *obj;
8987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8989 return SWIG_Py_Void();
8990 }
8991
8992 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 return SWIG_Python_InitShadowInstance(args);
8994 }
8995
8996 SWIGINTERN int DefaultPosition_set(PyObject *) {
8997 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8998 return 1;
8999 }
9000
9001
9002 SWIGINTERN PyObject *DefaultPosition_get(void) {
9003 PyObject *pyobj = 0;
9004
9005 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9006 return pyobj;
9007 }
9008
9009
9010 SWIGINTERN int DefaultSize_set(PyObject *) {
9011 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9012 return 1;
9013 }
9014
9015
9016 SWIGINTERN PyObject *DefaultSize_get(void) {
9017 PyObject *pyobj = 0;
9018
9019 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9020 return pyobj;
9021 }
9022
9023
9024 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj = 0;
9026 PyObject *arg1 = (PyObject *) 0 ;
9027 wxPyInputStream *result = 0 ;
9028 PyObject * obj0 = 0 ;
9029 char * kwnames[] = {
9030 (char *) "p", NULL
9031 };
9032
9033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9034 arg1 = obj0;
9035 {
9036 PyThreadState* __tstate = wxPyBeginAllowThreads();
9037 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 PyObject *swig_obj[1] ;
9054
9055 if (!args) SWIG_fail;
9056 swig_obj[0] = args;
9057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9060 }
9061 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 delete arg1;
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 resultobj = SWIG_Py_Void();
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9077 PyObject *resultobj = 0;
9078 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9079 void *argp1 = 0 ;
9080 int res1 = 0 ;
9081 PyObject *swig_obj[1] ;
9082
9083 if (!args) SWIG_fail;
9084 swig_obj[0] = args;
9085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9088 }
9089 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 (arg1)->close();
9093 wxPyEndAllowThreads(__tstate);
9094 if (PyErr_Occurred()) SWIG_fail;
9095 }
9096 resultobj = SWIG_Py_Void();
9097 return resultobj;
9098 fail:
9099 return NULL;
9100 }
9101
9102
9103 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 PyObject *resultobj = 0;
9105 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 PyObject *swig_obj[1] ;
9109
9110 if (!args) SWIG_fail;
9111 swig_obj[0] = args;
9112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9113 if (!SWIG_IsOK(res1)) {
9114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9115 }
9116 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9117 {
9118 PyThreadState* __tstate = wxPyBeginAllowThreads();
9119 (arg1)->flush();
9120 wxPyEndAllowThreads(__tstate);
9121 if (PyErr_Occurred()) SWIG_fail;
9122 }
9123 resultobj = SWIG_Py_Void();
9124 return resultobj;
9125 fail:
9126 return NULL;
9127 }
9128
9129
9130 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9131 PyObject *resultobj = 0;
9132 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9133 bool result;
9134 void *argp1 = 0 ;
9135 int res1 = 0 ;
9136 PyObject *swig_obj[1] ;
9137
9138 if (!args) SWIG_fail;
9139 swig_obj[0] = args;
9140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9143 }
9144 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (bool)(arg1)->eof();
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 {
9152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9153 }
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9161 PyObject *resultobj = 0;
9162 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9163 int arg2 = (int) -1 ;
9164 PyObject *result = 0 ;
9165 void *argp1 = 0 ;
9166 int res1 = 0 ;
9167 int val2 ;
9168 int ecode2 = 0 ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "size", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9181 if (obj1) {
9182 ecode2 = SWIG_AsVal_int(obj1, &val2);
9183 if (!SWIG_IsOK(ecode2)) {
9184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9185 }
9186 arg2 = static_cast< int >(val2);
9187 }
9188 {
9189 PyThreadState* __tstate = wxPyBeginAllowThreads();
9190 result = (PyObject *)(arg1)->read(arg2);
9191 wxPyEndAllowThreads(__tstate);
9192 if (PyErr_Occurred()) SWIG_fail;
9193 }
9194 resultobj = result;
9195 return resultobj;
9196 fail:
9197 return NULL;
9198 }
9199
9200
9201 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj = 0;
9203 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9204 int arg2 = (int) -1 ;
9205 PyObject *result = 0 ;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 int val2 ;
9209 int ecode2 = 0 ;
9210 PyObject * obj0 = 0 ;
9211 PyObject * obj1 = 0 ;
9212 char * kwnames[] = {
9213 (char *) "self",(char *) "size", NULL
9214 };
9215
9216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9218 if (!SWIG_IsOK(res1)) {
9219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9220 }
9221 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9222 if (obj1) {
9223 ecode2 = SWIG_AsVal_int(obj1, &val2);
9224 if (!SWIG_IsOK(ecode2)) {
9225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9226 }
9227 arg2 = static_cast< int >(val2);
9228 }
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (PyObject *)(arg1)->readline(arg2);
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = result;
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj = 0;
9244 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9245 int arg2 = (int) -1 ;
9246 PyObject *result = 0 ;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 int val2 ;
9250 int ecode2 = 0 ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char * kwnames[] = {
9254 (char *) "self",(char *) "sizehint", NULL
9255 };
9256
9257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9261 }
9262 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9263 if (obj1) {
9264 ecode2 = SWIG_AsVal_int(obj1, &val2);
9265 if (!SWIG_IsOK(ecode2)) {
9266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9267 }
9268 arg2 = static_cast< int >(val2);
9269 }
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (PyObject *)(arg1)->readlines(arg2);
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = result;
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9284 PyObject *resultobj = 0;
9285 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9286 int arg2 ;
9287 int arg3 = (int) 0 ;
9288 void *argp1 = 0 ;
9289 int res1 = 0 ;
9290 int val2 ;
9291 int ecode2 = 0 ;
9292 int val3 ;
9293 int ecode3 = 0 ;
9294 PyObject * obj0 = 0 ;
9295 PyObject * obj1 = 0 ;
9296 PyObject * obj2 = 0 ;
9297 char * kwnames[] = {
9298 (char *) "self",(char *) "offset",(char *) "whence", NULL
9299 };
9300
9301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9303 if (!SWIG_IsOK(res1)) {
9304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9305 }
9306 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9307 ecode2 = SWIG_AsVal_int(obj1, &val2);
9308 if (!SWIG_IsOK(ecode2)) {
9309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9310 }
9311 arg2 = static_cast< int >(val2);
9312 if (obj2) {
9313 ecode3 = SWIG_AsVal_int(obj2, &val3);
9314 if (!SWIG_IsOK(ecode3)) {
9315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9316 }
9317 arg3 = static_cast< int >(val3);
9318 }
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 (arg1)->seek(arg2,arg3);
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_Py_Void();
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9333 PyObject *resultobj = 0;
9334 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9335 int result;
9336 void *argp1 = 0 ;
9337 int res1 = 0 ;
9338 PyObject *swig_obj[1] ;
9339
9340 if (!args) SWIG_fail;
9341 swig_obj[0] = args;
9342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9343 if (!SWIG_IsOK(res1)) {
9344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9345 }
9346 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 result = (int)(arg1)->tell();
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_From_int(static_cast< int >(result));
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9363 char result;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 PyObject *swig_obj[1] ;
9367
9368 if (!args) SWIG_fail;
9369 swig_obj[0] = args;
9370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9373 }
9374 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (char)(arg1)->Peek();
9378 wxPyEndAllowThreads(__tstate);
9379 if (PyErr_Occurred()) SWIG_fail;
9380 }
9381 resultobj = SWIG_From_char(static_cast< char >(result));
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9389 PyObject *resultobj = 0;
9390 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9391 char result;
9392 void *argp1 = 0 ;
9393 int res1 = 0 ;
9394 PyObject *swig_obj[1] ;
9395
9396 if (!args) SWIG_fail;
9397 swig_obj[0] = args;
9398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9399 if (!SWIG_IsOK(res1)) {
9400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9401 }
9402 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (char)(arg1)->GetC();
9406 wxPyEndAllowThreads(__tstate);
9407 if (PyErr_Occurred()) SWIG_fail;
9408 }
9409 resultobj = SWIG_From_char(static_cast< char >(result));
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9417 PyObject *resultobj = 0;
9418 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9419 size_t result;
9420 void *argp1 = 0 ;
9421 int res1 = 0 ;
9422 PyObject *swig_obj[1] ;
9423
9424 if (!args) SWIG_fail;
9425 swig_obj[0] = args;
9426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9427 if (!SWIG_IsOK(res1)) {
9428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9429 }
9430 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = (size_t)(arg1)->LastRead();
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 PyObject *resultobj = 0;
9446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9447 bool result;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 PyObject *swig_obj[1] ;
9451
9452 if (!args) SWIG_fail;
9453 swig_obj[0] = args;
9454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9457 }
9458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (bool)(arg1)->CanRead();
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 {
9466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9467 }
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9475 PyObject *resultobj = 0;
9476 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9477 bool result;
9478 void *argp1 = 0 ;
9479 int res1 = 0 ;
9480 PyObject *swig_obj[1] ;
9481
9482 if (!args) SWIG_fail;
9483 swig_obj[0] = args;
9484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9487 }
9488 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 result = (bool)(arg1)->Eof();
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 {
9496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9497 }
9498 return resultobj;
9499 fail:
9500 return NULL;
9501 }
9502
9503
9504 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj = 0;
9506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9507 char arg2 ;
9508 bool result;
9509 void *argp1 = 0 ;
9510 int res1 = 0 ;
9511 char val2 ;
9512 int ecode2 = 0 ;
9513 PyObject * obj0 = 0 ;
9514 PyObject * obj1 = 0 ;
9515 char * kwnames[] = {
9516 (char *) "self",(char *) "c", NULL
9517 };
9518
9519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9521 if (!SWIG_IsOK(res1)) {
9522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9523 }
9524 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9525 ecode2 = SWIG_AsVal_char(obj1, &val2);
9526 if (!SWIG_IsOK(ecode2)) {
9527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9528 }
9529 arg2 = static_cast< char >(val2);
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 result = (bool)(arg1)->Ungetch(arg2);
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 {
9537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9538 }
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9546 PyObject *resultobj = 0;
9547 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9548 long arg2 ;
9549 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9550 long result;
9551 void *argp1 = 0 ;
9552 int res1 = 0 ;
9553 long val2 ;
9554 int ecode2 = 0 ;
9555 int val3 ;
9556 int ecode3 = 0 ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 PyObject * obj2 = 0 ;
9560 char * kwnames[] = {
9561 (char *) "self",(char *) "pos",(char *) "mode", NULL
9562 };
9563
9564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9568 }
9569 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9570 ecode2 = SWIG_AsVal_long(obj1, &val2);
9571 if (!SWIG_IsOK(ecode2)) {
9572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9573 }
9574 arg2 = static_cast< long >(val2);
9575 if (obj2) {
9576 ecode3 = SWIG_AsVal_int(obj2, &val3);
9577 if (!SWIG_IsOK(ecode3)) {
9578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9579 }
9580 arg3 = static_cast< wxSeekMode >(val3);
9581 }
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (long)(arg1)->SeekI(arg2,arg3);
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_From_long(static_cast< long >(result));
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9596 PyObject *resultobj = 0;
9597 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9598 long result;
9599 void *argp1 = 0 ;
9600 int res1 = 0 ;
9601 PyObject *swig_obj[1] ;
9602
9603 if (!args) SWIG_fail;
9604 swig_obj[0] = args;
9605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9606 if (!SWIG_IsOK(res1)) {
9607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9608 }
9609 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = (long)(arg1)->TellI();
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 resultobj = SWIG_From_long(static_cast< long >(result));
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9624 PyObject *obj;
9625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9626 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9627 return SWIG_Py_Void();
9628 }
9629
9630 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9631 return SWIG_Python_InitShadowInstance(args);
9632 }
9633
9634 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = 0;
9636 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9637 PyObject *arg2 = (PyObject *) 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char * kwnames[] = {
9643 (char *) "self",(char *) "obj", NULL
9644 };
9645
9646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9648 if (!SWIG_IsOK(res1)) {
9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9650 }
9651 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9652 arg2 = obj1;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 wxOutputStream_write(arg1,arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9669 size_t result;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9679 }
9680 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9695 PyObject *obj;
9696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9697 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9698 return SWIG_Py_Void();
9699 }
9700
9701 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxInputStream *arg1 = (wxInputStream *) 0 ;
9704 wxString *arg2 = 0 ;
9705 wxString *arg3 = 0 ;
9706 wxString *arg4 = 0 ;
9707 wxDateTime arg5 ;
9708 wxFSFile *result = 0 ;
9709 wxPyInputStream *temp1 ;
9710 bool temp2 = false ;
9711 bool temp3 = false ;
9712 bool temp4 = false ;
9713 void *argp5 ;
9714 int res5 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 PyObject * obj2 = 0 ;
9718 PyObject * obj3 = 0 ;
9719 PyObject * obj4 = 0 ;
9720 char * kwnames[] = {
9721 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9722 };
9723
9724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9725 {
9726 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9727 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9728 } else {
9729 PyErr_Clear(); // clear the failure of the wxPyConvert above
9730 arg1 = wxPyCBInputStream_create(obj0, true);
9731 if (arg1 == NULL) {
9732 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9733 SWIG_fail;
9734 }
9735 }
9736 }
9737 {
9738 arg2 = wxString_in_helper(obj1);
9739 if (arg2 == NULL) SWIG_fail;
9740 temp2 = true;
9741 }
9742 {
9743 arg3 = wxString_in_helper(obj2);
9744 if (arg3 == NULL) SWIG_fail;
9745 temp3 = true;
9746 }
9747 {
9748 arg4 = wxString_in_helper(obj3);
9749 if (arg4 == NULL) SWIG_fail;
9750 temp4 = true;
9751 }
9752 {
9753 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9754 if (!SWIG_IsOK(res5)) {
9755 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9756 }
9757 if (!argp5) {
9758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9759 } else {
9760 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9761 arg5 = *temp;
9762 if (SWIG_IsNewObj(res5)) delete temp;
9763 }
9764 }
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9772 {
9773 if (temp2)
9774 delete arg2;
9775 }
9776 {
9777 if (temp3)
9778 delete arg3;
9779 }
9780 {
9781 if (temp4)
9782 delete arg4;
9783 }
9784 return resultobj;
9785 fail:
9786 {
9787 if (temp2)
9788 delete arg2;
9789 }
9790 {
9791 if (temp3)
9792 delete arg3;
9793 }
9794 {
9795 if (temp4)
9796 delete arg4;
9797 }
9798 return NULL;
9799 }
9800
9801
9802 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9803 PyObject *resultobj = 0;
9804 wxFSFile *arg1 = (wxFSFile *) 0 ;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 PyObject *swig_obj[1] ;
9808
9809 if (!args) SWIG_fail;
9810 swig_obj[0] = args;
9811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9812 if (!SWIG_IsOK(res1)) {
9813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9814 }
9815 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 delete arg1;
9819
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 resultobj = SWIG_Py_Void();
9824 return resultobj;
9825 fail:
9826 return NULL;
9827 }
9828
9829
9830 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9831 PyObject *resultobj = 0;
9832 wxFSFile *arg1 = (wxFSFile *) 0 ;
9833 wxInputStream *result = 0 ;
9834 void *argp1 = 0 ;
9835 int res1 = 0 ;
9836 PyObject *swig_obj[1] ;
9837
9838 if (!args) SWIG_fail;
9839 swig_obj[0] = args;
9840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9841 if (!SWIG_IsOK(res1)) {
9842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9843 }
9844 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (wxInputStream *)(arg1)->GetStream();
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 wxPyInputStream * _ptr = NULL;
9853
9854 if (result) {
9855 _ptr = new wxPyInputStream(result);
9856 }
9857 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxFSFile *arg1 = (wxFSFile *) 0 ;
9868 void *argp1 = 0 ;
9869 int res1 = 0 ;
9870 PyObject *swig_obj[1] ;
9871
9872 if (!args) SWIG_fail;
9873 swig_obj[0] = args;
9874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9875 if (!SWIG_IsOK(res1)) {
9876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9877 }
9878 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 (arg1)->DetachStream();
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 resultobj = SWIG_Py_Void();
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9893 PyObject *resultobj = 0;
9894 wxFSFile *arg1 = (wxFSFile *) 0 ;
9895 wxString *result = 0 ;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 PyObject *swig_obj[1] ;
9899
9900 if (!args) SWIG_fail;
9901 swig_obj[0] = args;
9902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9903 if (!SWIG_IsOK(res1)) {
9904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9905 }
9906 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 {
9910 wxString const &_result_ref = (arg1)->GetMimeType();
9911 result = (wxString *) &_result_ref;
9912 }
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9930 PyObject *resultobj = 0;
9931 wxFSFile *arg1 = (wxFSFile *) 0 ;
9932 wxString *result = 0 ;
9933 void *argp1 = 0 ;
9934 int res1 = 0 ;
9935 PyObject *swig_obj[1] ;
9936
9937 if (!args) SWIG_fail;
9938 swig_obj[0] = args;
9939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9940 if (!SWIG_IsOK(res1)) {
9941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9942 }
9943 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 {
9947 wxString const &_result_ref = (arg1)->GetLocation();
9948 result = (wxString *) &_result_ref;
9949 }
9950 wxPyEndAllowThreads(__tstate);
9951 if (PyErr_Occurred()) SWIG_fail;
9952 }
9953 {
9954 #if wxUSE_UNICODE
9955 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9956 #else
9957 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9958 #endif
9959 }
9960 return resultobj;
9961 fail:
9962 return NULL;
9963 }
9964
9965
9966 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9967 PyObject *resultobj = 0;
9968 wxFSFile *arg1 = (wxFSFile *) 0 ;
9969 wxString *result = 0 ;
9970 void *argp1 = 0 ;
9971 int res1 = 0 ;
9972 PyObject *swig_obj[1] ;
9973
9974 if (!args) SWIG_fail;
9975 swig_obj[0] = args;
9976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9977 if (!SWIG_IsOK(res1)) {
9978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9979 }
9980 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 {
9984 wxString const &_result_ref = (arg1)->GetAnchor();
9985 result = (wxString *) &_result_ref;
9986 }
9987 wxPyEndAllowThreads(__tstate);
9988 if (PyErr_Occurred()) SWIG_fail;
9989 }
9990 {
9991 #if wxUSE_UNICODE
9992 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9993 #else
9994 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9995 #endif
9996 }
9997 return resultobj;
9998 fail:
9999 return NULL;
10000 }
10001
10002
10003 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10004 PyObject *resultobj = 0;
10005 wxFSFile *arg1 = (wxFSFile *) 0 ;
10006 wxDateTime result;
10007 void *argp1 = 0 ;
10008 int res1 = 0 ;
10009 PyObject *swig_obj[1] ;
10010
10011 if (!args) SWIG_fail;
10012 swig_obj[0] = args;
10013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10014 if (!SWIG_IsOK(res1)) {
10015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10016 }
10017 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10018 {
10019 PyThreadState* __tstate = wxPyBeginAllowThreads();
10020 result = (arg1)->GetModificationTime();
10021 wxPyEndAllowThreads(__tstate);
10022 if (PyErr_Occurred()) SWIG_fail;
10023 }
10024 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10025 return resultobj;
10026 fail:
10027 return NULL;
10028 }
10029
10030
10031 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10032 PyObject *obj;
10033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10034 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10035 return SWIG_Py_Void();
10036 }
10037
10038 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10039 return SWIG_Python_InitShadowInstance(args);
10040 }
10041
10042 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *resultobj = 0;
10044 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10045 void *argp1 = 0 ;
10046 int res1 = 0 ;
10047 PyObject *swig_obj[1] ;
10048
10049 if (!args) SWIG_fail;
10050 swig_obj[0] = args;
10051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10052 if (!SWIG_IsOK(res1)) {
10053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10054 }
10055 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10056 {
10057 PyThreadState* __tstate = wxPyBeginAllowThreads();
10058 delete arg1;
10059
10060 wxPyEndAllowThreads(__tstate);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 resultobj = SWIG_Py_Void();
10064 return resultobj;
10065 fail:
10066 return NULL;
10067 }
10068
10069
10070 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10071 PyObject *obj;
10072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10073 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10074 return SWIG_Py_Void();
10075 }
10076
10077 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10078 PyObject *resultobj = 0;
10079 wxPyFileSystemHandler *result = 0 ;
10080
10081 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10082 {
10083 PyThreadState* __tstate = wxPyBeginAllowThreads();
10084 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10089 return resultobj;
10090 fail:
10091 return NULL;
10092 }
10093
10094
10095 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj = 0;
10097 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10098 PyObject *arg2 = (PyObject *) 0 ;
10099 PyObject *arg3 = (PyObject *) 0 ;
10100 void *argp1 = 0 ;
10101 int res1 = 0 ;
10102 PyObject * obj0 = 0 ;
10103 PyObject * obj1 = 0 ;
10104 PyObject * obj2 = 0 ;
10105 char * kwnames[] = {
10106 (char *) "self",(char *) "self",(char *) "_class", NULL
10107 };
10108
10109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10111 if (!SWIG_IsOK(res1)) {
10112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10113 }
10114 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10115 arg2 = obj1;
10116 arg3 = obj2;
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 (arg1)->_setCallbackInfo(arg2,arg3);
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 resultobj = SWIG_Py_Void();
10124 return resultobj;
10125 fail:
10126 return NULL;
10127 }
10128
10129
10130 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj = 0;
10132 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10133 wxString *arg2 = 0 ;
10134 bool result;
10135 void *argp1 = 0 ;
10136 int res1 = 0 ;
10137 bool temp2 = false ;
10138 PyObject * obj0 = 0 ;
10139 PyObject * obj1 = 0 ;
10140 char * kwnames[] = {
10141 (char *) "self",(char *) "location", NULL
10142 };
10143
10144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10146 if (!SWIG_IsOK(res1)) {
10147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10148 }
10149 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10150 {
10151 arg2 = wxString_in_helper(obj1);
10152 if (arg2 == NULL) SWIG_fail;
10153 temp2 = true;
10154 }
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 {
10162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10163 }
10164 {
10165 if (temp2)
10166 delete arg2;
10167 }
10168 return resultobj;
10169 fail:
10170 {
10171 if (temp2)
10172 delete arg2;
10173 }
10174 return NULL;
10175 }
10176
10177
10178 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj = 0;
10180 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10181 wxFileSystem *arg2 = 0 ;
10182 wxString *arg3 = 0 ;
10183 wxFSFile *result = 0 ;
10184 void *argp1 = 0 ;
10185 int res1 = 0 ;
10186 void *argp2 = 0 ;
10187 int res2 = 0 ;
10188 bool temp3 = false ;
10189 PyObject * obj0 = 0 ;
10190 PyObject * obj1 = 0 ;
10191 PyObject * obj2 = 0 ;
10192 char * kwnames[] = {
10193 (char *) "self",(char *) "fs",(char *) "location", NULL
10194 };
10195
10196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10198 if (!SWIG_IsOK(res1)) {
10199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10200 }
10201 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10203 if (!SWIG_IsOK(res2)) {
10204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10205 }
10206 if (!argp2) {
10207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10208 }
10209 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10210 {
10211 arg3 = wxString_in_helper(obj2);
10212 if (arg3 == NULL) SWIG_fail;
10213 temp3 = true;
10214 }
10215 {
10216 PyThreadState* __tstate = wxPyBeginAllowThreads();
10217 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 {
10222 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10223 }
10224 {
10225 if (temp3)
10226 delete arg3;
10227 }
10228 return resultobj;
10229 fail:
10230 {
10231 if (temp3)
10232 delete arg3;
10233 }
10234 return NULL;
10235 }
10236
10237
10238 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj = 0;
10240 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10241 wxString *arg2 = 0 ;
10242 int arg3 = (int) 0 ;
10243 wxString result;
10244 void *argp1 = 0 ;
10245 int res1 = 0 ;
10246 bool temp2 = false ;
10247 int val3 ;
10248 int ecode3 = 0 ;
10249 PyObject * obj0 = 0 ;
10250 PyObject * obj1 = 0 ;
10251 PyObject * obj2 = 0 ;
10252 char * kwnames[] = {
10253 (char *) "self",(char *) "spec",(char *) "flags", NULL
10254 };
10255
10256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10258 if (!SWIG_IsOK(res1)) {
10259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10260 }
10261 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10262 {
10263 arg2 = wxString_in_helper(obj1);
10264 if (arg2 == NULL) SWIG_fail;
10265 temp2 = true;
10266 }
10267 if (obj2) {
10268 ecode3 = SWIG_AsVal_int(obj2, &val3);
10269 if (!SWIG_IsOK(ecode3)) {
10270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10271 }
10272 arg3 = static_cast< int >(val3);
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 {
10281 #if wxUSE_UNICODE
10282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10283 #else
10284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10285 #endif
10286 }
10287 {
10288 if (temp2)
10289 delete arg2;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10302 PyObject *resultobj = 0;
10303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10304 wxString result;
10305 void *argp1 = 0 ;
10306 int res1 = 0 ;
10307 PyObject *swig_obj[1] ;
10308
10309 if (!args) SWIG_fail;
10310 swig_obj[0] = args;
10311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10312 if (!SWIG_IsOK(res1)) {
10313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10314 }
10315 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 result = (arg1)->FindNext();
10319 wxPyEndAllowThreads(__tstate);
10320 if (PyErr_Occurred()) SWIG_fail;
10321 }
10322 {
10323 #if wxUSE_UNICODE
10324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10325 #else
10326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10327 #endif
10328 }
10329 return resultobj;
10330 fail:
10331 return NULL;
10332 }
10333
10334
10335 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10336 PyObject *resultobj = 0;
10337 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10338 wxString *arg2 = 0 ;
10339 wxString result;
10340 void *argp1 = 0 ;
10341 int res1 = 0 ;
10342 bool temp2 = false ;
10343 PyObject * obj0 = 0 ;
10344 PyObject * obj1 = 0 ;
10345 char * kwnames[] = {
10346 (char *) "self",(char *) "location", NULL
10347 };
10348
10349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10351 if (!SWIG_IsOK(res1)) {
10352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10353 }
10354 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10355 {
10356 arg2 = wxString_in_helper(obj1);
10357 if (arg2 == NULL) SWIG_fail;
10358 temp2 = true;
10359 }
10360 {
10361 PyThreadState* __tstate = wxPyBeginAllowThreads();
10362 result = (arg1)->GetProtocol((wxString const &)*arg2);
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 {
10367 #if wxUSE_UNICODE
10368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10369 #else
10370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10371 #endif
10372 }
10373 {
10374 if (temp2)
10375 delete arg2;
10376 }
10377 return resultobj;
10378 fail:
10379 {
10380 if (temp2)
10381 delete arg2;
10382 }
10383 return NULL;
10384 }
10385
10386
10387 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10388 PyObject *resultobj = 0;
10389 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10390 wxString *arg2 = 0 ;
10391 wxString result;
10392 void *argp1 = 0 ;
10393 int res1 = 0 ;
10394 bool temp2 = false ;
10395 PyObject * obj0 = 0 ;
10396 PyObject * obj1 = 0 ;
10397 char * kwnames[] = {
10398 (char *) "self",(char *) "location", NULL
10399 };
10400
10401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10403 if (!SWIG_IsOK(res1)) {
10404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10405 }
10406 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10407 {
10408 arg2 = wxString_in_helper(obj1);
10409 if (arg2 == NULL) SWIG_fail;
10410 temp2 = true;
10411 }
10412 {
10413 PyThreadState* __tstate = wxPyBeginAllowThreads();
10414 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10415 wxPyEndAllowThreads(__tstate);
10416 if (PyErr_Occurred()) SWIG_fail;
10417 }
10418 {
10419 #if wxUSE_UNICODE
10420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10421 #else
10422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10423 #endif
10424 }
10425 {
10426 if (temp2)
10427 delete arg2;
10428 }
10429 return resultobj;
10430 fail:
10431 {
10432 if (temp2)
10433 delete arg2;
10434 }
10435 return NULL;
10436 }
10437
10438
10439 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10440 PyObject *resultobj = 0;
10441 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10442 wxString *arg2 = 0 ;
10443 wxString result;
10444 void *argp1 = 0 ;
10445 int res1 = 0 ;
10446 bool temp2 = false ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449 char * kwnames[] = {
10450 (char *) "self",(char *) "location", NULL
10451 };
10452
10453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10455 if (!SWIG_IsOK(res1)) {
10456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10457 }
10458 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10459 {
10460 arg2 = wxString_in_helper(obj1);
10461 if (arg2 == NULL) SWIG_fail;
10462 temp2 = true;
10463 }
10464 {
10465 PyThreadState* __tstate = wxPyBeginAllowThreads();
10466 result = (arg1)->GetAnchor((wxString const &)*arg2);
10467 wxPyEndAllowThreads(__tstate);
10468 if (PyErr_Occurred()) SWIG_fail;
10469 }
10470 {
10471 #if wxUSE_UNICODE
10472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10473 #else
10474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10475 #endif
10476 }
10477 {
10478 if (temp2)
10479 delete arg2;
10480 }
10481 return resultobj;
10482 fail:
10483 {
10484 if (temp2)
10485 delete arg2;
10486 }
10487 return NULL;
10488 }
10489
10490
10491 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10492 PyObject *resultobj = 0;
10493 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10494 wxString *arg2 = 0 ;
10495 wxString result;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 bool temp2 = false ;
10499 PyObject * obj0 = 0 ;
10500 PyObject * obj1 = 0 ;
10501 char * kwnames[] = {
10502 (char *) "self",(char *) "location", NULL
10503 };
10504
10505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10507 if (!SWIG_IsOK(res1)) {
10508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10509 }
10510 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10511 {
10512 arg2 = wxString_in_helper(obj1);
10513 if (arg2 == NULL) SWIG_fail;
10514 temp2 = true;
10515 }
10516 {
10517 PyThreadState* __tstate = wxPyBeginAllowThreads();
10518 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10519 wxPyEndAllowThreads(__tstate);
10520 if (PyErr_Occurred()) SWIG_fail;
10521 }
10522 {
10523 #if wxUSE_UNICODE
10524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10525 #else
10526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10527 #endif
10528 }
10529 {
10530 if (temp2)
10531 delete arg2;
10532 }
10533 return resultobj;
10534 fail:
10535 {
10536 if (temp2)
10537 delete arg2;
10538 }
10539 return NULL;
10540 }
10541
10542
10543 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10544 PyObject *resultobj = 0;
10545 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10546 wxString *arg2 = 0 ;
10547 wxString result;
10548 void *argp1 = 0 ;
10549 int res1 = 0 ;
10550 bool temp2 = false ;
10551 PyObject * obj0 = 0 ;
10552 PyObject * obj1 = 0 ;
10553 char * kwnames[] = {
10554 (char *) "self",(char *) "location", NULL
10555 };
10556
10557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10559 if (!SWIG_IsOK(res1)) {
10560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10561 }
10562 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10563 {
10564 arg2 = wxString_in_helper(obj1);
10565 if (arg2 == NULL) SWIG_fail;
10566 temp2 = true;
10567 }
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 {
10575 #if wxUSE_UNICODE
10576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10577 #else
10578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10579 #endif
10580 }
10581 {
10582 if (temp2)
10583 delete arg2;
10584 }
10585 return resultobj;
10586 fail:
10587 {
10588 if (temp2)
10589 delete arg2;
10590 }
10591 return NULL;
10592 }
10593
10594
10595 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10596 PyObject *obj;
10597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10598 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10599 return SWIG_Py_Void();
10600 }
10601
10602 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10603 return SWIG_Python_InitShadowInstance(args);
10604 }
10605
10606 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10607 PyObject *resultobj = 0;
10608 wxFileSystem *result = 0 ;
10609
10610 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (wxFileSystem *)new wxFileSystem();
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 {
10618 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10619 }
10620 return resultobj;
10621 fail:
10622 return NULL;
10623 }
10624
10625
10626 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10627 PyObject *resultobj = 0;
10628 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10629 void *argp1 = 0 ;
10630 int res1 = 0 ;
10631 PyObject *swig_obj[1] ;
10632
10633 if (!args) SWIG_fail;
10634 swig_obj[0] = args;
10635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10636 if (!SWIG_IsOK(res1)) {
10637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10638 }
10639 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10640 {
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 delete arg1;
10643
10644 wxPyEndAllowThreads(__tstate);
10645 if (PyErr_Occurred()) SWIG_fail;
10646 }
10647 resultobj = SWIG_Py_Void();
10648 return resultobj;
10649 fail:
10650 return NULL;
10651 }
10652
10653
10654 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj = 0;
10656 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10657 wxString *arg2 = 0 ;
10658 bool arg3 = (bool) false ;
10659 void *argp1 = 0 ;
10660 int res1 = 0 ;
10661 bool temp2 = false ;
10662 bool val3 ;
10663 int ecode3 = 0 ;
10664 PyObject * obj0 = 0 ;
10665 PyObject * obj1 = 0 ;
10666 PyObject * obj2 = 0 ;
10667 char * kwnames[] = {
10668 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10669 };
10670
10671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10673 if (!SWIG_IsOK(res1)) {
10674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10675 }
10676 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10677 {
10678 arg2 = wxString_in_helper(obj1);
10679 if (arg2 == NULL) SWIG_fail;
10680 temp2 = true;
10681 }
10682 if (obj2) {
10683 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10684 if (!SWIG_IsOK(ecode3)) {
10685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10686 }
10687 arg3 = static_cast< bool >(val3);
10688 }
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10692 wxPyEndAllowThreads(__tstate);
10693 if (PyErr_Occurred()) SWIG_fail;
10694 }
10695 resultobj = SWIG_Py_Void();
10696 {
10697 if (temp2)
10698 delete arg2;
10699 }
10700 return resultobj;
10701 fail:
10702 {
10703 if (temp2)
10704 delete arg2;
10705 }
10706 return NULL;
10707 }
10708
10709
10710 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10711 PyObject *resultobj = 0;
10712 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10713 wxString result;
10714 void *argp1 = 0 ;
10715 int res1 = 0 ;
10716 PyObject *swig_obj[1] ;
10717
10718 if (!args) SWIG_fail;
10719 swig_obj[0] = args;
10720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10721 if (!SWIG_IsOK(res1)) {
10722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10723 }
10724 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 result = (arg1)->GetPath();
10728 wxPyEndAllowThreads(__tstate);
10729 if (PyErr_Occurred()) SWIG_fail;
10730 }
10731 {
10732 #if wxUSE_UNICODE
10733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10734 #else
10735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10736 #endif
10737 }
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj = 0;
10746 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10747 wxString *arg2 = 0 ;
10748 wxFSFile *result = 0 ;
10749 void *argp1 = 0 ;
10750 int res1 = 0 ;
10751 bool temp2 = false ;
10752 PyObject * obj0 = 0 ;
10753 PyObject * obj1 = 0 ;
10754 char * kwnames[] = {
10755 (char *) "self",(char *) "location", NULL
10756 };
10757
10758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10760 if (!SWIG_IsOK(res1)) {
10761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10762 }
10763 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10764 {
10765 arg2 = wxString_in_helper(obj1);
10766 if (arg2 == NULL) SWIG_fail;
10767 temp2 = true;
10768 }
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 {
10776 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10777 }
10778 {
10779 if (temp2)
10780 delete arg2;
10781 }
10782 return resultobj;
10783 fail:
10784 {
10785 if (temp2)
10786 delete arg2;
10787 }
10788 return NULL;
10789 }
10790
10791
10792 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj = 0;
10794 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10795 wxString *arg2 = 0 ;
10796 int arg3 = (int) 0 ;
10797 wxString result;
10798 void *argp1 = 0 ;
10799 int res1 = 0 ;
10800 bool temp2 = false ;
10801 int val3 ;
10802 int ecode3 = 0 ;
10803 PyObject * obj0 = 0 ;
10804 PyObject * obj1 = 0 ;
10805 PyObject * obj2 = 0 ;
10806 char * kwnames[] = {
10807 (char *) "self",(char *) "spec",(char *) "flags", NULL
10808 };
10809
10810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10812 if (!SWIG_IsOK(res1)) {
10813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10814 }
10815 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10816 {
10817 arg2 = wxString_in_helper(obj1);
10818 if (arg2 == NULL) SWIG_fail;
10819 temp2 = true;
10820 }
10821 if (obj2) {
10822 ecode3 = SWIG_AsVal_int(obj2, &val3);
10823 if (!SWIG_IsOK(ecode3)) {
10824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10825 }
10826 arg3 = static_cast< int >(val3);
10827 }
10828 {
10829 PyThreadState* __tstate = wxPyBeginAllowThreads();
10830 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10831 wxPyEndAllowThreads(__tstate);
10832 if (PyErr_Occurred()) SWIG_fail;
10833 }
10834 {
10835 #if wxUSE_UNICODE
10836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10837 #else
10838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10839 #endif
10840 }
10841 {
10842 if (temp2)
10843 delete arg2;
10844 }
10845 return resultobj;
10846 fail:
10847 {
10848 if (temp2)
10849 delete arg2;
10850 }
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10856 PyObject *resultobj = 0;
10857 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10858 wxString result;
10859 void *argp1 = 0 ;
10860 int res1 = 0 ;
10861 PyObject *swig_obj[1] ;
10862
10863 if (!args) SWIG_fail;
10864 swig_obj[0] = args;
10865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10866 if (!SWIG_IsOK(res1)) {
10867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10868 }
10869 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10870 {
10871 PyThreadState* __tstate = wxPyBeginAllowThreads();
10872 result = (arg1)->FindNext();
10873 wxPyEndAllowThreads(__tstate);
10874 if (PyErr_Occurred()) SWIG_fail;
10875 }
10876 {
10877 #if wxUSE_UNICODE
10878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10879 #else
10880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10881 #endif
10882 }
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj = 0;
10891 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10892 int res1 = 0 ;
10893 PyObject * obj0 = 0 ;
10894 char * kwnames[] = {
10895 (char *) "handler", NULL
10896 };
10897
10898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10899 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10900 if (!SWIG_IsOK(res1)) {
10901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10902 }
10903 {
10904 PyThreadState* __tstate = wxPyBeginAllowThreads();
10905 wxFileSystem::AddHandler(arg1);
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 resultobj = SWIG_Py_Void();
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj = 0;
10918 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10919 wxFileSystemHandler *result = 0 ;
10920 void *argp1 = 0 ;
10921 int res1 = 0 ;
10922 PyObject * obj0 = 0 ;
10923 char * kwnames[] = {
10924 (char *) "handler", NULL
10925 };
10926
10927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
10928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10929 if (!SWIG_IsOK(res1)) {
10930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10931 }
10932 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10947 PyObject *resultobj = 0;
10948
10949 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10950 {
10951 PyThreadState* __tstate = wxPyBeginAllowThreads();
10952 wxFileSystem::CleanUpHandlers();
10953 wxPyEndAllowThreads(__tstate);
10954 if (PyErr_Occurred()) SWIG_fail;
10955 }
10956 resultobj = SWIG_Py_Void();
10957 return resultobj;
10958 fail:
10959 return NULL;
10960 }
10961
10962
10963 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10964 PyObject *resultobj = 0;
10965 wxString *arg1 = 0 ;
10966 wxString result;
10967 bool temp1 = false ;
10968 PyObject * obj0 = 0 ;
10969 char * kwnames[] = {
10970 (char *) "filename", NULL
10971 };
10972
10973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10974 {
10975 arg1 = wxString_in_helper(obj0);
10976 if (arg1 == NULL) SWIG_fail;
10977 temp1 = true;
10978 }
10979 {
10980 PyThreadState* __tstate = wxPyBeginAllowThreads();
10981 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10982 wxPyEndAllowThreads(__tstate);
10983 if (PyErr_Occurred()) SWIG_fail;
10984 }
10985 {
10986 #if wxUSE_UNICODE
10987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10988 #else
10989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10990 #endif
10991 }
10992 {
10993 if (temp1)
10994 delete arg1;
10995 }
10996 return resultobj;
10997 fail:
10998 {
10999 if (temp1)
11000 delete arg1;
11001 }
11002 return NULL;
11003 }
11004
11005
11006 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11007 PyObject *resultobj = 0;
11008 wxString *arg1 = 0 ;
11009 wxString result;
11010 bool temp1 = false ;
11011 PyObject * obj0 = 0 ;
11012 char * kwnames[] = {
11013 (char *) "url", NULL
11014 };
11015
11016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11017 {
11018 arg1 = wxString_in_helper(obj0);
11019 if (arg1 == NULL) SWIG_fail;
11020 temp1 = true;
11021 }
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 {
11029 #if wxUSE_UNICODE
11030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11031 #else
11032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11033 #endif
11034 }
11035 {
11036 if (temp1)
11037 delete arg1;
11038 }
11039 return resultobj;
11040 fail:
11041 {
11042 if (temp1)
11043 delete arg1;
11044 }
11045 return NULL;
11046 }
11047
11048
11049 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11050 PyObject *obj;
11051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11052 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11053 return SWIG_Py_Void();
11054 }
11055
11056 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11057 return SWIG_Python_InitShadowInstance(args);
11058 }
11059
11060 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11061 PyObject *resultobj = 0;
11062 wxInternetFSHandler *result = 0 ;
11063
11064 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11065 {
11066 PyThreadState* __tstate = wxPyBeginAllowThreads();
11067 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11068 wxPyEndAllowThreads(__tstate);
11069 if (PyErr_Occurred()) SWIG_fail;
11070 }
11071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11079 PyObject *resultobj = 0;
11080 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11081 wxString *arg2 = 0 ;
11082 bool result;
11083 void *argp1 = 0 ;
11084 int res1 = 0 ;
11085 bool temp2 = false ;
11086 PyObject * obj0 = 0 ;
11087 PyObject * obj1 = 0 ;
11088 char * kwnames[] = {
11089 (char *) "self",(char *) "location", NULL
11090 };
11091
11092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11094 if (!SWIG_IsOK(res1)) {
11095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11096 }
11097 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11098 {
11099 arg2 = wxString_in_helper(obj1);
11100 if (arg2 == NULL) SWIG_fail;
11101 temp2 = true;
11102 }
11103 {
11104 PyThreadState* __tstate = wxPyBeginAllowThreads();
11105 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 {
11110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11111 }
11112 {
11113 if (temp2)
11114 delete arg2;
11115 }
11116 return resultobj;
11117 fail:
11118 {
11119 if (temp2)
11120 delete arg2;
11121 }
11122 return NULL;
11123 }
11124
11125
11126 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11127 PyObject *resultobj = 0;
11128 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11129 wxFileSystem *arg2 = 0 ;
11130 wxString *arg3 = 0 ;
11131 wxFSFile *result = 0 ;
11132 void *argp1 = 0 ;
11133 int res1 = 0 ;
11134 void *argp2 = 0 ;
11135 int res2 = 0 ;
11136 bool temp3 = false ;
11137 PyObject * obj0 = 0 ;
11138 PyObject * obj1 = 0 ;
11139 PyObject * obj2 = 0 ;
11140 char * kwnames[] = {
11141 (char *) "self",(char *) "fs",(char *) "location", NULL
11142 };
11143
11144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11146 if (!SWIG_IsOK(res1)) {
11147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11148 }
11149 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11150 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11151 if (!SWIG_IsOK(res2)) {
11152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11153 }
11154 if (!argp2) {
11155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11156 }
11157 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11158 {
11159 arg3 = wxString_in_helper(obj2);
11160 if (arg3 == NULL) SWIG_fail;
11161 temp3 = true;
11162 }
11163 {
11164 PyThreadState* __tstate = wxPyBeginAllowThreads();
11165 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11166 wxPyEndAllowThreads(__tstate);
11167 if (PyErr_Occurred()) SWIG_fail;
11168 }
11169 {
11170 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11171 }
11172 {
11173 if (temp3)
11174 delete arg3;
11175 }
11176 return resultobj;
11177 fail:
11178 {
11179 if (temp3)
11180 delete arg3;
11181 }
11182 return NULL;
11183 }
11184
11185
11186 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11187 PyObject *obj;
11188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11189 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11190 return SWIG_Py_Void();
11191 }
11192
11193 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11194 return SWIG_Python_InitShadowInstance(args);
11195 }
11196
11197 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11198 PyObject *resultobj = 0;
11199 wxZipFSHandler *result = 0 ;
11200
11201 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 result = (wxZipFSHandler *)new wxZipFSHandler();
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj = 0;
11217 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11218 wxString *arg2 = 0 ;
11219 bool result;
11220 void *argp1 = 0 ;
11221 int res1 = 0 ;
11222 bool temp2 = false ;
11223 PyObject * obj0 = 0 ;
11224 PyObject * obj1 = 0 ;
11225 char * kwnames[] = {
11226 (char *) "self",(char *) "location", NULL
11227 };
11228
11229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11231 if (!SWIG_IsOK(res1)) {
11232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11233 }
11234 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11235 {
11236 arg2 = wxString_in_helper(obj1);
11237 if (arg2 == NULL) SWIG_fail;
11238 temp2 = true;
11239 }
11240 {
11241 PyThreadState* __tstate = wxPyBeginAllowThreads();
11242 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11243 wxPyEndAllowThreads(__tstate);
11244 if (PyErr_Occurred()) SWIG_fail;
11245 }
11246 {
11247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11248 }
11249 {
11250 if (temp2)
11251 delete arg2;
11252 }
11253 return resultobj;
11254 fail:
11255 {
11256 if (temp2)
11257 delete arg2;
11258 }
11259 return NULL;
11260 }
11261
11262
11263 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj = 0;
11265 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11266 wxFileSystem *arg2 = 0 ;
11267 wxString *arg3 = 0 ;
11268 wxFSFile *result = 0 ;
11269 void *argp1 = 0 ;
11270 int res1 = 0 ;
11271 void *argp2 = 0 ;
11272 int res2 = 0 ;
11273 bool temp3 = false ;
11274 PyObject * obj0 = 0 ;
11275 PyObject * obj1 = 0 ;
11276 PyObject * obj2 = 0 ;
11277 char * kwnames[] = {
11278 (char *) "self",(char *) "fs",(char *) "location", NULL
11279 };
11280
11281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11283 if (!SWIG_IsOK(res1)) {
11284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11285 }
11286 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11287 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11288 if (!SWIG_IsOK(res2)) {
11289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11290 }
11291 if (!argp2) {
11292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11293 }
11294 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11295 {
11296 arg3 = wxString_in_helper(obj2);
11297 if (arg3 == NULL) SWIG_fail;
11298 temp3 = true;
11299 }
11300 {
11301 PyThreadState* __tstate = wxPyBeginAllowThreads();
11302 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 {
11307 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11308 }
11309 {
11310 if (temp3)
11311 delete arg3;
11312 }
11313 return resultobj;
11314 fail:
11315 {
11316 if (temp3)
11317 delete arg3;
11318 }
11319 return NULL;
11320 }
11321
11322
11323 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11324 PyObject *resultobj = 0;
11325 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11326 wxString *arg2 = 0 ;
11327 int arg3 = (int) 0 ;
11328 wxString result;
11329 void *argp1 = 0 ;
11330 int res1 = 0 ;
11331 bool temp2 = false ;
11332 int val3 ;
11333 int ecode3 = 0 ;
11334 PyObject * obj0 = 0 ;
11335 PyObject * obj1 = 0 ;
11336 PyObject * obj2 = 0 ;
11337 char * kwnames[] = {
11338 (char *) "self",(char *) "spec",(char *) "flags", NULL
11339 };
11340
11341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11343 if (!SWIG_IsOK(res1)) {
11344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11345 }
11346 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11347 {
11348 arg2 = wxString_in_helper(obj1);
11349 if (arg2 == NULL) SWIG_fail;
11350 temp2 = true;
11351 }
11352 if (obj2) {
11353 ecode3 = SWIG_AsVal_int(obj2, &val3);
11354 if (!SWIG_IsOK(ecode3)) {
11355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11356 }
11357 arg3 = static_cast< int >(val3);
11358 }
11359 {
11360 PyThreadState* __tstate = wxPyBeginAllowThreads();
11361 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11362 wxPyEndAllowThreads(__tstate);
11363 if (PyErr_Occurred()) SWIG_fail;
11364 }
11365 {
11366 #if wxUSE_UNICODE
11367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11368 #else
11369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11370 #endif
11371 }
11372 {
11373 if (temp2)
11374 delete arg2;
11375 }
11376 return resultobj;
11377 fail:
11378 {
11379 if (temp2)
11380 delete arg2;
11381 }
11382 return NULL;
11383 }
11384
11385
11386 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11387 PyObject *resultobj = 0;
11388 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11389 wxString result;
11390 void *argp1 = 0 ;
11391 int res1 = 0 ;
11392 PyObject *swig_obj[1] ;
11393
11394 if (!args) SWIG_fail;
11395 swig_obj[0] = args;
11396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11397 if (!SWIG_IsOK(res1)) {
11398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11399 }
11400 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 result = (arg1)->FindNext();
11404 wxPyEndAllowThreads(__tstate);
11405 if (PyErr_Occurred()) SWIG_fail;
11406 }
11407 {
11408 #if wxUSE_UNICODE
11409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11410 #else
11411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11412 #endif
11413 }
11414 return resultobj;
11415 fail:
11416 return NULL;
11417 }
11418
11419
11420 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11421 PyObject *obj;
11422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11423 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11424 return SWIG_Py_Void();
11425 }
11426
11427 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11428 return SWIG_Python_InitShadowInstance(args);
11429 }
11430
11431 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxString *arg1 = 0 ;
11434 wxImage *arg2 = 0 ;
11435 long arg3 ;
11436 bool temp1 = false ;
11437 void *argp2 = 0 ;
11438 int res2 = 0 ;
11439 long val3 ;
11440 int ecode3 = 0 ;
11441 PyObject * obj0 = 0 ;
11442 PyObject * obj1 = 0 ;
11443 PyObject * obj2 = 0 ;
11444 char * kwnames[] = {
11445 (char *) "filename",(char *) "image",(char *) "type", NULL
11446 };
11447
11448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11449 {
11450 arg1 = wxString_in_helper(obj0);
11451 if (arg1 == NULL) SWIG_fail;
11452 temp1 = true;
11453 }
11454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11455 if (!SWIG_IsOK(res2)) {
11456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11457 }
11458 if (!argp2) {
11459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11460 }
11461 arg2 = reinterpret_cast< wxImage * >(argp2);
11462 ecode3 = SWIG_AsVal_long(obj2, &val3);
11463 if (!SWIG_IsOK(ecode3)) {
11464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11465 }
11466 arg3 = static_cast< long >(val3);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 {
11475 if (temp1)
11476 delete arg1;
11477 }
11478 return resultobj;
11479 fail:
11480 {
11481 if (temp1)
11482 delete arg1;
11483 }
11484 return NULL;
11485 }
11486
11487
11488 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11489 PyObject *resultobj = 0;
11490 wxString *arg1 = 0 ;
11491 wxBitmap *arg2 = 0 ;
11492 long arg3 ;
11493 bool temp1 = false ;
11494 void *argp2 = 0 ;
11495 int res2 = 0 ;
11496 long val3 ;
11497 int ecode3 = 0 ;
11498 PyObject * obj0 = 0 ;
11499 PyObject * obj1 = 0 ;
11500 PyObject * obj2 = 0 ;
11501 char * kwnames[] = {
11502 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11503 };
11504
11505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11506 {
11507 arg1 = wxString_in_helper(obj0);
11508 if (arg1 == NULL) SWIG_fail;
11509 temp1 = true;
11510 }
11511 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11512 if (!SWIG_IsOK(res2)) {
11513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11514 }
11515 if (!argp2) {
11516 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11517 }
11518 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11519 ecode3 = SWIG_AsVal_long(obj2, &val3);
11520 if (!SWIG_IsOK(ecode3)) {
11521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11522 }
11523 arg3 = static_cast< long >(val3);
11524 {
11525 PyThreadState* __tstate = wxPyBeginAllowThreads();
11526 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_Py_Void();
11531 {
11532 if (temp1)
11533 delete arg1;
11534 }
11535 return resultobj;
11536 fail:
11537 {
11538 if (temp1)
11539 delete arg1;
11540 }
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj = 0;
11547 wxString *arg1 = 0 ;
11548 PyObject *arg2 = (PyObject *) 0 ;
11549 bool temp1 = false ;
11550 PyObject * obj0 = 0 ;
11551 PyObject * obj1 = 0 ;
11552 char * kwnames[] = {
11553 (char *) "filename",(char *) "data", NULL
11554 };
11555
11556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11557 {
11558 arg1 = wxString_in_helper(obj0);
11559 if (arg1 == NULL) SWIG_fail;
11560 temp1 = true;
11561 }
11562 arg2 = obj1;
11563 {
11564 PyThreadState* __tstate = wxPyBeginAllowThreads();
11565 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 resultobj = SWIG_Py_Void();
11570 {
11571 if (temp1)
11572 delete arg1;
11573 }
11574 return resultobj;
11575 fail:
11576 {
11577 if (temp1)
11578 delete arg1;
11579 }
11580 return NULL;
11581 }
11582
11583
11584 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11585 PyObject *resultobj = 0;
11586 wxMemoryFSHandler *result = 0 ;
11587
11588 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11592 wxPyEndAllowThreads(__tstate);
11593 if (PyErr_Occurred()) SWIG_fail;
11594 }
11595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11603 PyObject *resultobj = 0;
11604 wxString *arg1 = 0 ;
11605 bool temp1 = false ;
11606 PyObject * obj0 = 0 ;
11607 char * kwnames[] = {
11608 (char *) "filename", NULL
11609 };
11610
11611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11612 {
11613 arg1 = wxString_in_helper(obj0);
11614 if (arg1 == NULL) SWIG_fail;
11615 temp1 = true;
11616 }
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 resultobj = SWIG_Py_Void();
11624 {
11625 if (temp1)
11626 delete arg1;
11627 }
11628 return resultobj;
11629 fail:
11630 {
11631 if (temp1)
11632 delete arg1;
11633 }
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11639 PyObject *resultobj = 0;
11640 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11641 wxString *arg2 = 0 ;
11642 bool result;
11643 void *argp1 = 0 ;
11644 int res1 = 0 ;
11645 bool temp2 = false ;
11646 PyObject * obj0 = 0 ;
11647 PyObject * obj1 = 0 ;
11648 char * kwnames[] = {
11649 (char *) "self",(char *) "location", NULL
11650 };
11651
11652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11654 if (!SWIG_IsOK(res1)) {
11655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11656 }
11657 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11658 {
11659 arg2 = wxString_in_helper(obj1);
11660 if (arg2 == NULL) SWIG_fail;
11661 temp2 = true;
11662 }
11663 {
11664 PyThreadState* __tstate = wxPyBeginAllowThreads();
11665 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11666 wxPyEndAllowThreads(__tstate);
11667 if (PyErr_Occurred()) SWIG_fail;
11668 }
11669 {
11670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11671 }
11672 {
11673 if (temp2)
11674 delete arg2;
11675 }
11676 return resultobj;
11677 fail:
11678 {
11679 if (temp2)
11680 delete arg2;
11681 }
11682 return NULL;
11683 }
11684
11685
11686 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11687 PyObject *resultobj = 0;
11688 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11689 wxFileSystem *arg2 = 0 ;
11690 wxString *arg3 = 0 ;
11691 wxFSFile *result = 0 ;
11692 void *argp1 = 0 ;
11693 int res1 = 0 ;
11694 void *argp2 = 0 ;
11695 int res2 = 0 ;
11696 bool temp3 = false ;
11697 PyObject * obj0 = 0 ;
11698 PyObject * obj1 = 0 ;
11699 PyObject * obj2 = 0 ;
11700 char * kwnames[] = {
11701 (char *) "self",(char *) "fs",(char *) "location", NULL
11702 };
11703
11704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11706 if (!SWIG_IsOK(res1)) {
11707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11708 }
11709 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11710 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11711 if (!SWIG_IsOK(res2)) {
11712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11713 }
11714 if (!argp2) {
11715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11716 }
11717 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11718 {
11719 arg3 = wxString_in_helper(obj2);
11720 if (arg3 == NULL) SWIG_fail;
11721 temp3 = true;
11722 }
11723 {
11724 PyThreadState* __tstate = wxPyBeginAllowThreads();
11725 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11726 wxPyEndAllowThreads(__tstate);
11727 if (PyErr_Occurred()) SWIG_fail;
11728 }
11729 {
11730 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11731 }
11732 {
11733 if (temp3)
11734 delete arg3;
11735 }
11736 return resultobj;
11737 fail:
11738 {
11739 if (temp3)
11740 delete arg3;
11741 }
11742 return NULL;
11743 }
11744
11745
11746 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11747 PyObject *resultobj = 0;
11748 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11749 wxString *arg2 = 0 ;
11750 int arg3 = (int) 0 ;
11751 wxString result;
11752 void *argp1 = 0 ;
11753 int res1 = 0 ;
11754 bool temp2 = false ;
11755 int val3 ;
11756 int ecode3 = 0 ;
11757 PyObject * obj0 = 0 ;
11758 PyObject * obj1 = 0 ;
11759 PyObject * obj2 = 0 ;
11760 char * kwnames[] = {
11761 (char *) "self",(char *) "spec",(char *) "flags", NULL
11762 };
11763
11764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11768 }
11769 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11770 {
11771 arg2 = wxString_in_helper(obj1);
11772 if (arg2 == NULL) SWIG_fail;
11773 temp2 = true;
11774 }
11775 if (obj2) {
11776 ecode3 = SWIG_AsVal_int(obj2, &val3);
11777 if (!SWIG_IsOK(ecode3)) {
11778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11779 }
11780 arg3 = static_cast< int >(val3);
11781 }
11782 {
11783 PyThreadState* __tstate = wxPyBeginAllowThreads();
11784 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 {
11789 #if wxUSE_UNICODE
11790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11791 #else
11792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11793 #endif
11794 }
11795 {
11796 if (temp2)
11797 delete arg2;
11798 }
11799 return resultobj;
11800 fail:
11801 {
11802 if (temp2)
11803 delete arg2;
11804 }
11805 return NULL;
11806 }
11807
11808
11809 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11810 PyObject *resultobj = 0;
11811 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11812 wxString result;
11813 void *argp1 = 0 ;
11814 int res1 = 0 ;
11815 PyObject *swig_obj[1] ;
11816
11817 if (!args) SWIG_fail;
11818 swig_obj[0] = args;
11819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11820 if (!SWIG_IsOK(res1)) {
11821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11822 }
11823 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11824 {
11825 PyThreadState* __tstate = wxPyBeginAllowThreads();
11826 result = (arg1)->FindNext();
11827 wxPyEndAllowThreads(__tstate);
11828 if (PyErr_Occurred()) SWIG_fail;
11829 }
11830 {
11831 #if wxUSE_UNICODE
11832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11833 #else
11834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11835 #endif
11836 }
11837 return resultobj;
11838 fail:
11839 return NULL;
11840 }
11841
11842
11843 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11844 PyObject *obj;
11845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11846 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11847 return SWIG_Py_Void();
11848 }
11849
11850 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11851 return SWIG_Python_InitShadowInstance(args);
11852 }
11853
11854 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11855 PyObject *resultobj = 0;
11856 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11857 wxString result;
11858 void *argp1 = 0 ;
11859 int res1 = 0 ;
11860 PyObject *swig_obj[1] ;
11861
11862 if (!args) SWIG_fail;
11863 swig_obj[0] = args;
11864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11865 if (!SWIG_IsOK(res1)) {
11866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11867 }
11868 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 result = (arg1)->GetName();
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 #if wxUSE_UNICODE
11877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11878 #else
11879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11880 #endif
11881 }
11882 return resultobj;
11883 fail:
11884 return NULL;
11885 }
11886
11887
11888 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11889 PyObject *resultobj = 0;
11890 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11891 wxString result;
11892 void *argp1 = 0 ;
11893 int res1 = 0 ;
11894 PyObject *swig_obj[1] ;
11895
11896 if (!args) SWIG_fail;
11897 swig_obj[0] = args;
11898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11899 if (!SWIG_IsOK(res1)) {
11900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11901 }
11902 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (arg1)->GetExtension();
11906 wxPyEndAllowThreads(__tstate);
11907 if (PyErr_Occurred()) SWIG_fail;
11908 }
11909 {
11910 #if wxUSE_UNICODE
11911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11912 #else
11913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11914 #endif
11915 }
11916 return resultobj;
11917 fail:
11918 return NULL;
11919 }
11920
11921
11922 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11923 PyObject *resultobj = 0;
11924 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11925 long result;
11926 void *argp1 = 0 ;
11927 int res1 = 0 ;
11928 PyObject *swig_obj[1] ;
11929
11930 if (!args) SWIG_fail;
11931 swig_obj[0] = args;
11932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11933 if (!SWIG_IsOK(res1)) {
11934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11935 }
11936 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11937 {
11938 PyThreadState* __tstate = wxPyBeginAllowThreads();
11939 result = (long)(arg1)->GetType();
11940 wxPyEndAllowThreads(__tstate);
11941 if (PyErr_Occurred()) SWIG_fail;
11942 }
11943 resultobj = SWIG_From_long(static_cast< long >(result));
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11951 PyObject *resultobj = 0;
11952 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11953 wxString result;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 PyObject *swig_obj[1] ;
11957
11958 if (!args) SWIG_fail;
11959 swig_obj[0] = args;
11960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11961 if (!SWIG_IsOK(res1)) {
11962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11963 }
11964 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 result = (arg1)->GetMimeType();
11968 wxPyEndAllowThreads(__tstate);
11969 if (PyErr_Occurred()) SWIG_fail;
11970 }
11971 {
11972 #if wxUSE_UNICODE
11973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11974 #else
11975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11976 #endif
11977 }
11978 return resultobj;
11979 fail:
11980 return NULL;
11981 }
11982
11983
11984 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11985 PyObject *resultobj = 0;
11986 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11987 wxString *arg2 = 0 ;
11988 bool result;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991 bool temp2 = false ;
11992 PyObject * obj0 = 0 ;
11993 PyObject * obj1 = 0 ;
11994 char * kwnames[] = {
11995 (char *) "self",(char *) "name", NULL
11996 };
11997
11998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12000 if (!SWIG_IsOK(res1)) {
12001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12002 }
12003 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12004 {
12005 arg2 = wxString_in_helper(obj1);
12006 if (arg2 == NULL) SWIG_fail;
12007 temp2 = true;
12008 }
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 {
12016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12017 }
12018 {
12019 if (temp2)
12020 delete arg2;
12021 }
12022 return resultobj;
12023 fail:
12024 {
12025 if (temp2)
12026 delete arg2;
12027 }
12028 return NULL;
12029 }
12030
12031
12032 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12033 PyObject *resultobj = 0;
12034 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12035 wxInputStream *arg2 = 0 ;
12036 bool result;
12037 void *argp1 = 0 ;
12038 int res1 = 0 ;
12039 wxPyInputStream *temp2 ;
12040 bool created2 ;
12041 PyObject * obj0 = 0 ;
12042 PyObject * obj1 = 0 ;
12043 char * kwnames[] = {
12044 (char *) "self",(char *) "stream", NULL
12045 };
12046
12047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12049 if (!SWIG_IsOK(res1)) {
12050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12051 }
12052 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12053 {
12054 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12055 arg2 = temp2->m_wxis;
12056 created2 = false;
12057 } else {
12058 PyErr_Clear(); // clear the failure of the wxPyConvert above
12059 arg2 = wxPyCBInputStream_create(obj1, false);
12060 if (arg2 == NULL) {
12061 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12062 SWIG_fail;
12063 }
12064 created2 = true;
12065 }
12066 }
12067 {
12068 PyThreadState* __tstate = wxPyBeginAllowThreads();
12069 result = (bool)(arg1)->CanRead(*arg2);
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 {
12074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12075 }
12076 {
12077 if (created2) delete arg2;
12078 }
12079 return resultobj;
12080 fail:
12081 {
12082 if (created2) delete arg2;
12083 }
12084 return NULL;
12085 }
12086
12087
12088 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12089 PyObject *resultobj = 0;
12090 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12091 wxString *arg2 = 0 ;
12092 void *argp1 = 0 ;
12093 int res1 = 0 ;
12094 bool temp2 = false ;
12095 PyObject * obj0 = 0 ;
12096 PyObject * obj1 = 0 ;
12097 char * kwnames[] = {
12098 (char *) "self",(char *) "name", NULL
12099 };
12100
12101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12103 if (!SWIG_IsOK(res1)) {
12104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12105 }
12106 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12107 {
12108 arg2 = wxString_in_helper(obj1);
12109 if (arg2 == NULL) SWIG_fail;
12110 temp2 = true;
12111 }
12112 {
12113 PyThreadState* __tstate = wxPyBeginAllowThreads();
12114 (arg1)->SetName((wxString const &)*arg2);
12115 wxPyEndAllowThreads(__tstate);
12116 if (PyErr_Occurred()) SWIG_fail;
12117 }
12118 resultobj = SWIG_Py_Void();
12119 {
12120 if (temp2)
12121 delete arg2;
12122 }
12123 return resultobj;
12124 fail:
12125 {
12126 if (temp2)
12127 delete arg2;
12128 }
12129 return NULL;
12130 }
12131
12132
12133 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj = 0;
12135 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12136 wxString *arg2 = 0 ;
12137 void *argp1 = 0 ;
12138 int res1 = 0 ;
12139 bool temp2 = false ;
12140 PyObject * obj0 = 0 ;
12141 PyObject * obj1 = 0 ;
12142 char * kwnames[] = {
12143 (char *) "self",(char *) "extension", NULL
12144 };
12145
12146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12148 if (!SWIG_IsOK(res1)) {
12149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12150 }
12151 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12152 {
12153 arg2 = wxString_in_helper(obj1);
12154 if (arg2 == NULL) SWIG_fail;
12155 temp2 = true;
12156 }
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 (arg1)->SetExtension((wxString const &)*arg2);
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_Py_Void();
12164 {
12165 if (temp2)
12166 delete arg2;
12167 }
12168 return resultobj;
12169 fail:
12170 {
12171 if (temp2)
12172 delete arg2;
12173 }
12174 return NULL;
12175 }
12176
12177
12178 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj = 0;
12180 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12181 long arg2 ;
12182 void *argp1 = 0 ;
12183 int res1 = 0 ;
12184 long val2 ;
12185 int ecode2 = 0 ;
12186 PyObject * obj0 = 0 ;
12187 PyObject * obj1 = 0 ;
12188 char * kwnames[] = {
12189 (char *) "self",(char *) "type", NULL
12190 };
12191
12192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12194 if (!SWIG_IsOK(res1)) {
12195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12196 }
12197 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12198 ecode2 = SWIG_AsVal_long(obj1, &val2);
12199 if (!SWIG_IsOK(ecode2)) {
12200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12201 }
12202 arg2 = static_cast< long >(val2);
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 (arg1)->SetType(arg2);
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 resultobj = SWIG_Py_Void();
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj = 0;
12218 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12219 wxString *arg2 = 0 ;
12220 void *argp1 = 0 ;
12221 int res1 = 0 ;
12222 bool temp2 = false ;
12223 PyObject * obj0 = 0 ;
12224 PyObject * obj1 = 0 ;
12225 char * kwnames[] = {
12226 (char *) "self",(char *) "mimetype", NULL
12227 };
12228
12229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12233 }
12234 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12235 {
12236 arg2 = wxString_in_helper(obj1);
12237 if (arg2 == NULL) SWIG_fail;
12238 temp2 = true;
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 (arg1)->SetMimeType((wxString const &)*arg2);
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 resultobj = SWIG_Py_Void();
12247 {
12248 if (temp2)
12249 delete arg2;
12250 }
12251 return resultobj;
12252 fail:
12253 {
12254 if (temp2)
12255 delete arg2;
12256 }
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12262 PyObject *obj;
12263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12264 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12265 return SWIG_Py_Void();
12266 }
12267
12268 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269 PyObject *resultobj = 0;
12270 wxPyImageHandler *result = 0 ;
12271
12272 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12273 {
12274 PyThreadState* __tstate = wxPyBeginAllowThreads();
12275 result = (wxPyImageHandler *)new wxPyImageHandler();
12276 wxPyEndAllowThreads(__tstate);
12277 if (PyErr_Occurred()) SWIG_fail;
12278 }
12279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12280 return resultobj;
12281 fail:
12282 return NULL;
12283 }
12284
12285
12286 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12287 PyObject *resultobj = 0;
12288 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12289 PyObject *arg2 = (PyObject *) 0 ;
12290 void *argp1 = 0 ;
12291 int res1 = 0 ;
12292 PyObject * obj0 = 0 ;
12293 PyObject * obj1 = 0 ;
12294 char * kwnames[] = {
12295 (char *) "self",(char *) "self", NULL
12296 };
12297
12298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12300 if (!SWIG_IsOK(res1)) {
12301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12302 }
12303 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12304 arg2 = obj1;
12305 {
12306 PyThreadState* __tstate = wxPyBeginAllowThreads();
12307 (arg1)->_SetSelf(arg2);
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 resultobj = SWIG_Py_Void();
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12319 PyObject *obj;
12320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12321 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12322 return SWIG_Py_Void();
12323 }
12324
12325 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12326 return SWIG_Python_InitShadowInstance(args);
12327 }
12328
12329 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12330 PyObject *resultobj = 0;
12331 wxImageHistogram *result = 0 ;
12332
12333 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 result = (wxImageHistogram *)new wxImageHistogram();
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12341 return resultobj;
12342 fail:
12343 return NULL;
12344 }
12345
12346
12347 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12348 PyObject *resultobj = 0;
12349 byte arg1 ;
12350 byte arg2 ;
12351 byte arg3 ;
12352 unsigned long result;
12353 unsigned char val1 ;
12354 int ecode1 = 0 ;
12355 unsigned char val2 ;
12356 int ecode2 = 0 ;
12357 unsigned char val3 ;
12358 int ecode3 = 0 ;
12359 PyObject * obj0 = 0 ;
12360 PyObject * obj1 = 0 ;
12361 PyObject * obj2 = 0 ;
12362 char * kwnames[] = {
12363 (char *) "r",(char *) "g",(char *) "b", NULL
12364 };
12365
12366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12367 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12368 if (!SWIG_IsOK(ecode1)) {
12369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12370 }
12371 arg1 = static_cast< byte >(val1);
12372 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12373 if (!SWIG_IsOK(ecode2)) {
12374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12375 }
12376 arg2 = static_cast< byte >(val2);
12377 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12378 if (!SWIG_IsOK(ecode3)) {
12379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12380 }
12381 arg3 = static_cast< byte >(val3);
12382 {
12383 PyThreadState* __tstate = wxPyBeginAllowThreads();
12384 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12385 wxPyEndAllowThreads(__tstate);
12386 if (PyErr_Occurred()) SWIG_fail;
12387 }
12388 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12396 PyObject *resultobj = 0;
12397 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12398 byte *arg2 = (byte *) 0 ;
12399 byte *arg3 = (byte *) 0 ;
12400 byte *arg4 = (byte *) 0 ;
12401 byte arg5 = (byte) 1 ;
12402 byte arg6 = (byte) 0 ;
12403 byte arg7 = (byte) 0 ;
12404 bool result;
12405 void *argp1 = 0 ;
12406 int res1 = 0 ;
12407 byte temp2 ;
12408 int res2 = SWIG_TMPOBJ ;
12409 byte temp3 ;
12410 int res3 = SWIG_TMPOBJ ;
12411 byte temp4 ;
12412 int res4 = SWIG_TMPOBJ ;
12413 unsigned char val5 ;
12414 int ecode5 = 0 ;
12415 unsigned char val6 ;
12416 int ecode6 = 0 ;
12417 unsigned char val7 ;
12418 int ecode7 = 0 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 PyObject * obj2 = 0 ;
12422 PyObject * obj3 = 0 ;
12423 char * kwnames[] = {
12424 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12425 };
12426
12427 arg2 = &temp2;
12428 arg3 = &temp3;
12429 arg4 = &temp4;
12430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12432 if (!SWIG_IsOK(res1)) {
12433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12434 }
12435 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12436 if (obj1) {
12437 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12438 if (!SWIG_IsOK(ecode5)) {
12439 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12440 }
12441 arg5 = static_cast< byte >(val5);
12442 }
12443 if (obj2) {
12444 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12445 if (!SWIG_IsOK(ecode6)) {
12446 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12447 }
12448 arg6 = static_cast< byte >(val6);
12449 }
12450 if (obj3) {
12451 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12452 if (!SWIG_IsOK(ecode7)) {
12453 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12454 }
12455 arg7 = static_cast< byte >(val7);
12456 }
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 {
12464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12465 }
12466 if (SWIG_IsTmpObj(res2)) {
12467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12468 } else {
12469 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12471 }
12472 if (SWIG_IsTmpObj(res3)) {
12473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12474 } else {
12475 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12477 }
12478 if (SWIG_IsTmpObj(res4)) {
12479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12480 } else {
12481 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12483 }
12484 return resultobj;
12485 fail:
12486 return NULL;
12487 }
12488
12489
12490 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12491 PyObject *resultobj = 0;
12492 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12493 unsigned long arg2 ;
12494 unsigned long result;
12495 void *argp1 = 0 ;
12496 int res1 = 0 ;
12497 unsigned long val2 ;
12498 int ecode2 = 0 ;
12499 PyObject * obj0 = 0 ;
12500 PyObject * obj1 = 0 ;
12501 char * kwnames[] = {
12502 (char *) "self",(char *) "key", NULL
12503 };
12504
12505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12507 if (!SWIG_IsOK(res1)) {
12508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12509 }
12510 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12511 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12512 if (!SWIG_IsOK(ecode2)) {
12513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12514 }
12515 arg2 = static_cast< unsigned long >(val2);
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12519 wxPyEndAllowThreads(__tstate);
12520 if (PyErr_Occurred()) SWIG_fail;
12521 }
12522 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = 0;
12531 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12532 byte arg2 ;
12533 byte arg3 ;
12534 byte arg4 ;
12535 unsigned long result;
12536 void *argp1 = 0 ;
12537 int res1 = 0 ;
12538 unsigned char val2 ;
12539 int ecode2 = 0 ;
12540 unsigned char val3 ;
12541 int ecode3 = 0 ;
12542 unsigned char val4 ;
12543 int ecode4 = 0 ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 PyObject * obj2 = 0 ;
12547 PyObject * obj3 = 0 ;
12548 char * kwnames[] = {
12549 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12550 };
12551
12552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12554 if (!SWIG_IsOK(res1)) {
12555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12556 }
12557 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12558 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12559 if (!SWIG_IsOK(ecode2)) {
12560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12561 }
12562 arg2 = static_cast< byte >(val2);
12563 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12564 if (!SWIG_IsOK(ecode3)) {
12565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12566 }
12567 arg3 = static_cast< byte >(val3);
12568 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12569 if (!SWIG_IsOK(ecode4)) {
12570 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12571 }
12572 arg4 = static_cast< byte >(val4);
12573 {
12574 PyThreadState* __tstate = wxPyBeginAllowThreads();
12575 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12576 wxPyEndAllowThreads(__tstate);
12577 if (PyErr_Occurred()) SWIG_fail;
12578 }
12579 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12580 return resultobj;
12581 fail:
12582 return NULL;
12583 }
12584
12585
12586 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12587 PyObject *resultobj = 0;
12588 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12589 wxColour *arg2 = 0 ;
12590 unsigned long result;
12591 void *argp1 = 0 ;
12592 int res1 = 0 ;
12593 wxColour temp2 ;
12594 PyObject * obj0 = 0 ;
12595 PyObject * obj1 = 0 ;
12596 char * kwnames[] = {
12597 (char *) "self",(char *) "colour", NULL
12598 };
12599
12600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12602 if (!SWIG_IsOK(res1)) {
12603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12604 }
12605 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12606 {
12607 arg2 = &temp2;
12608 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12609 }
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12613 wxPyEndAllowThreads(__tstate);
12614 if (PyErr_Occurred()) SWIG_fail;
12615 }
12616 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12617 return resultobj;
12618 fail:
12619 return NULL;
12620 }
12621
12622
12623 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12624 PyObject *obj;
12625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12626 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12627 return SWIG_Py_Void();
12628 }
12629
12630 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12631 return SWIG_Python_InitShadowInstance(args);
12632 }
12633
12634 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj = 0;
12636 byte arg1 = (byte) 0 ;
12637 byte arg2 = (byte) 0 ;
12638 byte arg3 = (byte) 0 ;
12639 wxImage_RGBValue *result = 0 ;
12640 unsigned char val1 ;
12641 int ecode1 = 0 ;
12642 unsigned char val2 ;
12643 int ecode2 = 0 ;
12644 unsigned char val3 ;
12645 int ecode3 = 0 ;
12646 PyObject * obj0 = 0 ;
12647 PyObject * obj1 = 0 ;
12648 PyObject * obj2 = 0 ;
12649 char * kwnames[] = {
12650 (char *) "r",(char *) "g",(char *) "b", NULL
12651 };
12652
12653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12654 if (obj0) {
12655 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12656 if (!SWIG_IsOK(ecode1)) {
12657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12658 }
12659 arg1 = static_cast< byte >(val1);
12660 }
12661 if (obj1) {
12662 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12663 if (!SWIG_IsOK(ecode2)) {
12664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12665 }
12666 arg2 = static_cast< byte >(val2);
12667 }
12668 if (obj2) {
12669 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12670 if (!SWIG_IsOK(ecode3)) {
12671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12672 }
12673 arg3 = static_cast< byte >(val3);
12674 }
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12682 return resultobj;
12683 fail:
12684 return NULL;
12685 }
12686
12687
12688 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12689 PyObject *resultobj = 0;
12690 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12691 byte arg2 ;
12692 void *argp1 = 0 ;
12693 int res1 = 0 ;
12694 unsigned char val2 ;
12695 int ecode2 = 0 ;
12696 PyObject *swig_obj[2] ;
12697
12698 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12700 if (!SWIG_IsOK(res1)) {
12701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12702 }
12703 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12704 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12705 if (!SWIG_IsOK(ecode2)) {
12706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12707 }
12708 arg2 = static_cast< byte >(val2);
12709 if (arg1) (arg1)->red = arg2;
12710
12711 resultobj = SWIG_Py_Void();
12712 return resultobj;
12713 fail:
12714 return NULL;
12715 }
12716
12717
12718 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12719 PyObject *resultobj = 0;
12720 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12721 byte result;
12722 void *argp1 = 0 ;
12723 int res1 = 0 ;
12724 PyObject *swig_obj[1] ;
12725
12726 if (!args) SWIG_fail;
12727 swig_obj[0] = args;
12728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12729 if (!SWIG_IsOK(res1)) {
12730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12731 }
12732 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12733 result = (byte) ((arg1)->red);
12734 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12742 PyObject *resultobj = 0;
12743 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12744 byte arg2 ;
12745 void *argp1 = 0 ;
12746 int res1 = 0 ;
12747 unsigned char val2 ;
12748 int ecode2 = 0 ;
12749 PyObject *swig_obj[2] ;
12750
12751 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12753 if (!SWIG_IsOK(res1)) {
12754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12755 }
12756 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12757 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12758 if (!SWIG_IsOK(ecode2)) {
12759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12760 }
12761 arg2 = static_cast< byte >(val2);
12762 if (arg1) (arg1)->green = arg2;
12763
12764 resultobj = SWIG_Py_Void();
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12772 PyObject *resultobj = 0;
12773 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12774 byte result;
12775 void *argp1 = 0 ;
12776 int res1 = 0 ;
12777 PyObject *swig_obj[1] ;
12778
12779 if (!args) SWIG_fail;
12780 swig_obj[0] = args;
12781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12782 if (!SWIG_IsOK(res1)) {
12783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12784 }
12785 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12786 result = (byte) ((arg1)->green);
12787 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12788 return resultobj;
12789 fail:
12790 return NULL;
12791 }
12792
12793
12794 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12795 PyObject *resultobj = 0;
12796 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12797 byte arg2 ;
12798 void *argp1 = 0 ;
12799 int res1 = 0 ;
12800 unsigned char val2 ;
12801 int ecode2 = 0 ;
12802 PyObject *swig_obj[2] ;
12803
12804 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12806 if (!SWIG_IsOK(res1)) {
12807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12808 }
12809 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12810 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12811 if (!SWIG_IsOK(ecode2)) {
12812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12813 }
12814 arg2 = static_cast< byte >(val2);
12815 if (arg1) (arg1)->blue = arg2;
12816
12817 resultobj = SWIG_Py_Void();
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12825 PyObject *resultobj = 0;
12826 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12827 byte result;
12828 void *argp1 = 0 ;
12829 int res1 = 0 ;
12830 PyObject *swig_obj[1] ;
12831
12832 if (!args) SWIG_fail;
12833 swig_obj[0] = args;
12834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12835 if (!SWIG_IsOK(res1)) {
12836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12837 }
12838 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12839 result = (byte) ((arg1)->blue);
12840 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12841 return resultobj;
12842 fail:
12843 return NULL;
12844 }
12845
12846
12847 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12848 PyObject *obj;
12849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12850 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12851 return SWIG_Py_Void();
12852 }
12853
12854 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 return SWIG_Python_InitShadowInstance(args);
12856 }
12857
12858 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12859 PyObject *resultobj = 0;
12860 double arg1 = (double) 0.0 ;
12861 double arg2 = (double) 0.0 ;
12862 double arg3 = (double) 0.0 ;
12863 wxImage_HSVValue *result = 0 ;
12864 double val1 ;
12865 int ecode1 = 0 ;
12866 double val2 ;
12867 int ecode2 = 0 ;
12868 double val3 ;
12869 int ecode3 = 0 ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 PyObject * obj2 = 0 ;
12873 char * kwnames[] = {
12874 (char *) "h",(char *) "s",(char *) "v", NULL
12875 };
12876
12877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12878 if (obj0) {
12879 ecode1 = SWIG_AsVal_double(obj0, &val1);
12880 if (!SWIG_IsOK(ecode1)) {
12881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12882 }
12883 arg1 = static_cast< double >(val1);
12884 }
12885 if (obj1) {
12886 ecode2 = SWIG_AsVal_double(obj1, &val2);
12887 if (!SWIG_IsOK(ecode2)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12889 }
12890 arg2 = static_cast< double >(val2);
12891 }
12892 if (obj2) {
12893 ecode3 = SWIG_AsVal_double(obj2, &val3);
12894 if (!SWIG_IsOK(ecode3)) {
12895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12896 }
12897 arg3 = static_cast< double >(val3);
12898 }
12899 {
12900 PyThreadState* __tstate = wxPyBeginAllowThreads();
12901 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12906 return resultobj;
12907 fail:
12908 return NULL;
12909 }
12910
12911
12912 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913 PyObject *resultobj = 0;
12914 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12915 double arg2 ;
12916 void *argp1 = 0 ;
12917 int res1 = 0 ;
12918 double val2 ;
12919 int ecode2 = 0 ;
12920 PyObject *swig_obj[2] ;
12921
12922 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12924 if (!SWIG_IsOK(res1)) {
12925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12926 }
12927 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12928 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12929 if (!SWIG_IsOK(ecode2)) {
12930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12931 }
12932 arg2 = static_cast< double >(val2);
12933 if (arg1) (arg1)->hue = arg2;
12934
12935 resultobj = SWIG_Py_Void();
12936 return resultobj;
12937 fail:
12938 return NULL;
12939 }
12940
12941
12942 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12943 PyObject *resultobj = 0;
12944 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12945 double result;
12946 void *argp1 = 0 ;
12947 int res1 = 0 ;
12948 PyObject *swig_obj[1] ;
12949
12950 if (!args) SWIG_fail;
12951 swig_obj[0] = args;
12952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12953 if (!SWIG_IsOK(res1)) {
12954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12955 }
12956 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12957 result = (double) ((arg1)->hue);
12958 resultobj = SWIG_From_double(static_cast< double >(result));
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12966 PyObject *resultobj = 0;
12967 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12968 double arg2 ;
12969 void *argp1 = 0 ;
12970 int res1 = 0 ;
12971 double val2 ;
12972 int ecode2 = 0 ;
12973 PyObject *swig_obj[2] ;
12974
12975 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12977 if (!SWIG_IsOK(res1)) {
12978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12979 }
12980 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12981 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12982 if (!SWIG_IsOK(ecode2)) {
12983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12984 }
12985 arg2 = static_cast< double >(val2);
12986 if (arg1) (arg1)->saturation = arg2;
12987
12988 resultobj = SWIG_Py_Void();
12989 return resultobj;
12990 fail:
12991 return NULL;
12992 }
12993
12994
12995 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12996 PyObject *resultobj = 0;
12997 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12998 double result;
12999 void *argp1 = 0 ;
13000 int res1 = 0 ;
13001 PyObject *swig_obj[1] ;
13002
13003 if (!args) SWIG_fail;
13004 swig_obj[0] = args;
13005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13006 if (!SWIG_IsOK(res1)) {
13007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13008 }
13009 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13010 result = (double) ((arg1)->saturation);
13011 resultobj = SWIG_From_double(static_cast< double >(result));
13012 return resultobj;
13013 fail:
13014 return NULL;
13015 }
13016
13017
13018 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13019 PyObject *resultobj = 0;
13020 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13021 double arg2 ;
13022 void *argp1 = 0 ;
13023 int res1 = 0 ;
13024 double val2 ;
13025 int ecode2 = 0 ;
13026 PyObject *swig_obj[2] ;
13027
13028 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13030 if (!SWIG_IsOK(res1)) {
13031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13032 }
13033 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13034 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13035 if (!SWIG_IsOK(ecode2)) {
13036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13037 }
13038 arg2 = static_cast< double >(val2);
13039 if (arg1) (arg1)->value = arg2;
13040
13041 resultobj = SWIG_Py_Void();
13042 return resultobj;
13043 fail:
13044 return NULL;
13045 }
13046
13047
13048 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13049 PyObject *resultobj = 0;
13050 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13051 double result;
13052 void *argp1 = 0 ;
13053 int res1 = 0 ;
13054 PyObject *swig_obj[1] ;
13055
13056 if (!args) SWIG_fail;
13057 swig_obj[0] = args;
13058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13059 if (!SWIG_IsOK(res1)) {
13060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13061 }
13062 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13063 result = (double) ((arg1)->value);
13064 resultobj = SWIG_From_double(static_cast< double >(result));
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13072 PyObject *obj;
13073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13074 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13075 return SWIG_Py_Void();
13076 }
13077
13078 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13079 return SWIG_Python_InitShadowInstance(args);
13080 }
13081
13082 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13083 PyObject *resultobj = 0;
13084 wxString *arg1 = 0 ;
13085 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13086 int arg3 = (int) -1 ;
13087 wxImage *result = 0 ;
13088 bool temp1 = false ;
13089 long val2 ;
13090 int ecode2 = 0 ;
13091 int val3 ;
13092 int ecode3 = 0 ;
13093 PyObject * obj0 = 0 ;
13094 PyObject * obj1 = 0 ;
13095 PyObject * obj2 = 0 ;
13096 char * kwnames[] = {
13097 (char *) "name",(char *) "type",(char *) "index", NULL
13098 };
13099
13100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13101 {
13102 arg1 = wxString_in_helper(obj0);
13103 if (arg1 == NULL) SWIG_fail;
13104 temp1 = true;
13105 }
13106 if (obj1) {
13107 ecode2 = SWIG_AsVal_long(obj1, &val2);
13108 if (!SWIG_IsOK(ecode2)) {
13109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13110 }
13111 arg2 = static_cast< long >(val2);
13112 }
13113 if (obj2) {
13114 ecode3 = SWIG_AsVal_int(obj2, &val3);
13115 if (!SWIG_IsOK(ecode3)) {
13116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13117 }
13118 arg3 = static_cast< int >(val3);
13119 }
13120 {
13121 PyThreadState* __tstate = wxPyBeginAllowThreads();
13122 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13127 {
13128 if (temp1)
13129 delete arg1;
13130 }
13131 return resultobj;
13132 fail:
13133 {
13134 if (temp1)
13135 delete arg1;
13136 }
13137 return NULL;
13138 }
13139
13140
13141 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13142 PyObject *resultobj = 0;
13143 wxImage *arg1 = (wxImage *) 0 ;
13144 void *argp1 = 0 ;
13145 int res1 = 0 ;
13146 PyObject *swig_obj[1] ;
13147
13148 if (!args) SWIG_fail;
13149 swig_obj[0] = args;
13150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13151 if (!SWIG_IsOK(res1)) {
13152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13153 }
13154 arg1 = reinterpret_cast< wxImage * >(argp1);
13155 {
13156 PyThreadState* __tstate = wxPyBeginAllowThreads();
13157 delete arg1;
13158
13159 wxPyEndAllowThreads(__tstate);
13160 if (PyErr_Occurred()) SWIG_fail;
13161 }
13162 resultobj = SWIG_Py_Void();
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj = 0;
13171 wxString *arg1 = 0 ;
13172 wxString *arg2 = 0 ;
13173 int arg3 = (int) -1 ;
13174 wxImage *result = 0 ;
13175 bool temp1 = false ;
13176 bool temp2 = false ;
13177 int val3 ;
13178 int ecode3 = 0 ;
13179 PyObject * obj0 = 0 ;
13180 PyObject * obj1 = 0 ;
13181 PyObject * obj2 = 0 ;
13182 char * kwnames[] = {
13183 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13184 };
13185
13186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13187 {
13188 arg1 = wxString_in_helper(obj0);
13189 if (arg1 == NULL) SWIG_fail;
13190 temp1 = true;
13191 }
13192 {
13193 arg2 = wxString_in_helper(obj1);
13194 if (arg2 == NULL) SWIG_fail;
13195 temp2 = true;
13196 }
13197 if (obj2) {
13198 ecode3 = SWIG_AsVal_int(obj2, &val3);
13199 if (!SWIG_IsOK(ecode3)) {
13200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13201 }
13202 arg3 = static_cast< int >(val3);
13203 }
13204 {
13205 PyThreadState* __tstate = wxPyBeginAllowThreads();
13206 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13207 wxPyEndAllowThreads(__tstate);
13208 if (PyErr_Occurred()) SWIG_fail;
13209 }
13210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13211 {
13212 if (temp1)
13213 delete arg1;
13214 }
13215 {
13216 if (temp2)
13217 delete arg2;
13218 }
13219 return resultobj;
13220 fail:
13221 {
13222 if (temp1)
13223 delete arg1;
13224 }
13225 {
13226 if (temp2)
13227 delete arg2;
13228 }
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj = 0;
13235 wxInputStream *arg1 = 0 ;
13236 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13237 int arg3 = (int) -1 ;
13238 wxImage *result = 0 ;
13239 wxPyInputStream *temp1 ;
13240 bool created1 ;
13241 long val2 ;
13242 int ecode2 = 0 ;
13243 int val3 ;
13244 int ecode3 = 0 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 PyObject * obj2 = 0 ;
13248 char * kwnames[] = {
13249 (char *) "stream",(char *) "type",(char *) "index", NULL
13250 };
13251
13252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13253 {
13254 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13255 arg1 = temp1->m_wxis;
13256 created1 = false;
13257 } else {
13258 PyErr_Clear(); // clear the failure of the wxPyConvert above
13259 arg1 = wxPyCBInputStream_create(obj0, false);
13260 if (arg1 == NULL) {
13261 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13262 SWIG_fail;
13263 }
13264 created1 = true;
13265 }
13266 }
13267 if (obj1) {
13268 ecode2 = SWIG_AsVal_long(obj1, &val2);
13269 if (!SWIG_IsOK(ecode2)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13271 }
13272 arg2 = static_cast< long >(val2);
13273 }
13274 if (obj2) {
13275 ecode3 = SWIG_AsVal_int(obj2, &val3);
13276 if (!SWIG_IsOK(ecode3)) {
13277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13278 }
13279 arg3 = static_cast< int >(val3);
13280 }
13281 {
13282 PyThreadState* __tstate = wxPyBeginAllowThreads();
13283 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13288 {
13289 if (created1) delete arg1;
13290 }
13291 return resultobj;
13292 fail:
13293 {
13294 if (created1) delete arg1;
13295 }
13296 return NULL;
13297 }
13298
13299
13300 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13301 PyObject *resultobj = 0;
13302 wxInputStream *arg1 = 0 ;
13303 wxString *arg2 = 0 ;
13304 int arg3 = (int) -1 ;
13305 wxImage *result = 0 ;
13306 wxPyInputStream *temp1 ;
13307 bool created1 ;
13308 bool temp2 = false ;
13309 int val3 ;
13310 int ecode3 = 0 ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 PyObject * obj2 = 0 ;
13314 char * kwnames[] = {
13315 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13316 };
13317
13318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13319 {
13320 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13321 arg1 = temp1->m_wxis;
13322 created1 = false;
13323 } else {
13324 PyErr_Clear(); // clear the failure of the wxPyConvert above
13325 arg1 = wxPyCBInputStream_create(obj0, false);
13326 if (arg1 == NULL) {
13327 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13328 SWIG_fail;
13329 }
13330 created1 = true;
13331 }
13332 }
13333 {
13334 arg2 = wxString_in_helper(obj1);
13335 if (arg2 == NULL) SWIG_fail;
13336 temp2 = true;
13337 }
13338 if (obj2) {
13339 ecode3 = SWIG_AsVal_int(obj2, &val3);
13340 if (!SWIG_IsOK(ecode3)) {
13341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13342 }
13343 arg3 = static_cast< int >(val3);
13344 }
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13352 {
13353 if (created1) delete arg1;
13354 }
13355 {
13356 if (temp2)
13357 delete arg2;
13358 }
13359 return resultobj;
13360 fail:
13361 {
13362 if (created1) delete arg1;
13363 }
13364 {
13365 if (temp2)
13366 delete arg2;
13367 }
13368 return NULL;
13369 }
13370
13371
13372 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj = 0;
13374 int arg1 = (int) 0 ;
13375 int arg2 = (int) 0 ;
13376 bool arg3 = (bool) true ;
13377 wxImage *result = 0 ;
13378 int val1 ;
13379 int ecode1 = 0 ;
13380 int val2 ;
13381 int ecode2 = 0 ;
13382 bool val3 ;
13383 int ecode3 = 0 ;
13384 PyObject * obj0 = 0 ;
13385 PyObject * obj1 = 0 ;
13386 PyObject * obj2 = 0 ;
13387 char * kwnames[] = {
13388 (char *) "width",(char *) "height",(char *) "clear", NULL
13389 };
13390
13391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13392 if (obj0) {
13393 ecode1 = SWIG_AsVal_int(obj0, &val1);
13394 if (!SWIG_IsOK(ecode1)) {
13395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13396 }
13397 arg1 = static_cast< int >(val1);
13398 }
13399 if (obj1) {
13400 ecode2 = SWIG_AsVal_int(obj1, &val2);
13401 if (!SWIG_IsOK(ecode2)) {
13402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13403 }
13404 arg2 = static_cast< int >(val2);
13405 }
13406 if (obj2) {
13407 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13408 if (!SWIG_IsOK(ecode3)) {
13409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13410 }
13411 arg3 = static_cast< bool >(val3);
13412 }
13413 {
13414 PyThreadState* __tstate = wxPyBeginAllowThreads();
13415 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13416 wxPyEndAllowThreads(__tstate);
13417 if (PyErr_Occurred()) SWIG_fail;
13418 }
13419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13420 return resultobj;
13421 fail:
13422 return NULL;
13423 }
13424
13425
13426 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj = 0;
13428 wxBitmap *arg1 = 0 ;
13429 wxImage *result = 0 ;
13430 void *argp1 = 0 ;
13431 int res1 = 0 ;
13432 PyObject * obj0 = 0 ;
13433 char * kwnames[] = {
13434 (char *) "bitmap", NULL
13435 };
13436
13437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13438 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13439 if (!SWIG_IsOK(res1)) {
13440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13441 }
13442 if (!argp1) {
13443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13444 }
13445 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13446 {
13447 if (!wxPyCheckForApp()) SWIG_fail;
13448 PyThreadState* __tstate = wxPyBeginAllowThreads();
13449 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13454 return resultobj;
13455 fail:
13456 return NULL;
13457 }
13458
13459
13460 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13461 PyObject *resultobj = 0;
13462 int arg1 ;
13463 int arg2 ;
13464 buffer arg3 ;
13465 int arg4 ;
13466 wxImage *result = 0 ;
13467 int val1 ;
13468 int ecode1 = 0 ;
13469 int val2 ;
13470 int ecode2 = 0 ;
13471 Py_ssize_t temp3 ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 PyObject * obj2 = 0 ;
13475 char * kwnames[] = {
13476 (char *) "width",(char *) "height",(char *) "data", NULL
13477 };
13478
13479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13480 ecode1 = SWIG_AsVal_int(obj0, &val1);
13481 if (!SWIG_IsOK(ecode1)) {
13482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13483 }
13484 arg1 = static_cast< int >(val1);
13485 ecode2 = SWIG_AsVal_int(obj1, &val2);
13486 if (!SWIG_IsOK(ecode2)) {
13487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13488 }
13489 arg2 = static_cast< int >(val2);
13490 {
13491 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13492 arg4 = (int)temp3;
13493 }
13494 {
13495 PyThreadState* __tstate = wxPyBeginAllowThreads();
13496 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13497 wxPyEndAllowThreads(__tstate);
13498 if (PyErr_Occurred()) SWIG_fail;
13499 }
13500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13501 return resultobj;
13502 fail:
13503 return NULL;
13504 }
13505
13506
13507 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13508 PyObject *resultobj = 0;
13509 int arg1 ;
13510 int arg2 ;
13511 buffer arg3 ;
13512 int arg4 ;
13513 buffer arg5 ;
13514 int arg6 ;
13515 wxImage *result = 0 ;
13516 int val1 ;
13517 int ecode1 = 0 ;
13518 int val2 ;
13519 int ecode2 = 0 ;
13520 Py_ssize_t temp3 ;
13521 Py_ssize_t temp5 ;
13522 PyObject * obj0 = 0 ;
13523 PyObject * obj1 = 0 ;
13524 PyObject * obj2 = 0 ;
13525 PyObject * obj3 = 0 ;
13526 char * kwnames[] = {
13527 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13528 };
13529
13530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13531 ecode1 = SWIG_AsVal_int(obj0, &val1);
13532 if (!SWIG_IsOK(ecode1)) {
13533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13534 }
13535 arg1 = static_cast< int >(val1);
13536 ecode2 = SWIG_AsVal_int(obj1, &val2);
13537 if (!SWIG_IsOK(ecode2)) {
13538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13539 }
13540 arg2 = static_cast< int >(val2);
13541 {
13542 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13543 arg4 = (int)temp3;
13544 }
13545 {
13546 if (obj3 != Py_None) {
13547 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13548 arg6 = (int)temp5;
13549 }
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13558 return resultobj;
13559 fail:
13560 return NULL;
13561 }
13562
13563
13564 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13565 PyObject *resultobj = 0;
13566 wxImage *arg1 = (wxImage *) 0 ;
13567 int arg2 ;
13568 int arg3 ;
13569 bool arg4 = (bool) true ;
13570 void *argp1 = 0 ;
13571 int res1 = 0 ;
13572 int val2 ;
13573 int ecode2 = 0 ;
13574 int val3 ;
13575 int ecode3 = 0 ;
13576 bool val4 ;
13577 int ecode4 = 0 ;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 PyObject * obj2 = 0 ;
13581 PyObject * obj3 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13588 if (!SWIG_IsOK(res1)) {
13589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13590 }
13591 arg1 = reinterpret_cast< wxImage * >(argp1);
13592 ecode2 = SWIG_AsVal_int(obj1, &val2);
13593 if (!SWIG_IsOK(ecode2)) {
13594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13595 }
13596 arg2 = static_cast< int >(val2);
13597 ecode3 = SWIG_AsVal_int(obj2, &val3);
13598 if (!SWIG_IsOK(ecode3)) {
13599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13600 }
13601 arg3 = static_cast< int >(val3);
13602 if (obj3) {
13603 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13604 if (!SWIG_IsOK(ecode4)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13606 }
13607 arg4 = static_cast< bool >(val4);
13608 }
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 (arg1)->Create(arg2,arg3,arg4);
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_Py_Void();
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13623 PyObject *resultobj = 0;
13624 wxImage *arg1 = (wxImage *) 0 ;
13625 void *argp1 = 0 ;
13626 int res1 = 0 ;
13627 PyObject *swig_obj[1] ;
13628
13629 if (!args) SWIG_fail;
13630 swig_obj[0] = args;
13631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13632 if (!SWIG_IsOK(res1)) {
13633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13634 }
13635 arg1 = reinterpret_cast< wxImage * >(argp1);
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 (arg1)->Destroy();
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 resultobj = SWIG_Py_Void();
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = 0;
13651 wxImage *arg1 = (wxImage *) 0 ;
13652 int arg2 ;
13653 int arg3 ;
13654 SwigValueWrapper<wxImage > result;
13655 void *argp1 = 0 ;
13656 int res1 = 0 ;
13657 int val2 ;
13658 int ecode2 = 0 ;
13659 int val3 ;
13660 int ecode3 = 0 ;
13661 PyObject * obj0 = 0 ;
13662 PyObject * obj1 = 0 ;
13663 PyObject * obj2 = 0 ;
13664 char * kwnames[] = {
13665 (char *) "self",(char *) "width",(char *) "height", NULL
13666 };
13667
13668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13670 if (!SWIG_IsOK(res1)) {
13671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13672 }
13673 arg1 = reinterpret_cast< wxImage * >(argp1);
13674 ecode2 = SWIG_AsVal_int(obj1, &val2);
13675 if (!SWIG_IsOK(ecode2)) {
13676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13677 }
13678 arg2 = static_cast< int >(val2);
13679 ecode3 = SWIG_AsVal_int(obj2, &val3);
13680 if (!SWIG_IsOK(ecode3)) {
13681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13682 }
13683 arg3 = static_cast< int >(val3);
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 result = (arg1)->Scale(arg2,arg3);
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13691 return resultobj;
13692 fail:
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxImage *arg1 = (wxImage *) 0 ;
13700 int arg2 ;
13701 int arg3 ;
13702 SwigValueWrapper<wxImage > result;
13703 void *argp1 = 0 ;
13704 int res1 = 0 ;
13705 int val2 ;
13706 int ecode2 = 0 ;
13707 int val3 ;
13708 int ecode3 = 0 ;
13709 PyObject * obj0 = 0 ;
13710 PyObject * obj1 = 0 ;
13711 PyObject * obj2 = 0 ;
13712 char * kwnames[] = {
13713 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13714 };
13715
13716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13718 if (!SWIG_IsOK(res1)) {
13719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13720 }
13721 arg1 = reinterpret_cast< wxImage * >(argp1);
13722 ecode2 = SWIG_AsVal_int(obj1, &val2);
13723 if (!SWIG_IsOK(ecode2)) {
13724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13725 }
13726 arg2 = static_cast< int >(val2);
13727 ecode3 = SWIG_AsVal_int(obj2, &val3);
13728 if (!SWIG_IsOK(ecode3)) {
13729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13730 }
13731 arg3 = static_cast< int >(val3);
13732 {
13733 PyThreadState* __tstate = wxPyBeginAllowThreads();
13734 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13735 wxPyEndAllowThreads(__tstate);
13736 if (PyErr_Occurred()) SWIG_fail;
13737 }
13738 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13739 return resultobj;
13740 fail:
13741 return NULL;
13742 }
13743
13744
13745 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13746 PyObject *resultobj = 0;
13747 wxImage *arg1 = (wxImage *) 0 ;
13748 int arg2 ;
13749 int arg3 ;
13750 wxImage *result = 0 ;
13751 void *argp1 = 0 ;
13752 int res1 = 0 ;
13753 int val2 ;
13754 int ecode2 = 0 ;
13755 int val3 ;
13756 int ecode3 = 0 ;
13757 PyObject * obj0 = 0 ;
13758 PyObject * obj1 = 0 ;
13759 PyObject * obj2 = 0 ;
13760 char * kwnames[] = {
13761 (char *) "self",(char *) "width",(char *) "height", NULL
13762 };
13763
13764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13766 if (!SWIG_IsOK(res1)) {
13767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13768 }
13769 arg1 = reinterpret_cast< wxImage * >(argp1);
13770 ecode2 = SWIG_AsVal_int(obj1, &val2);
13771 if (!SWIG_IsOK(ecode2)) {
13772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13773 }
13774 arg2 = static_cast< int >(val2);
13775 ecode3 = SWIG_AsVal_int(obj2, &val3);
13776 if (!SWIG_IsOK(ecode3)) {
13777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13778 }
13779 arg3 = static_cast< int >(val3);
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 {
13783 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13784 result = (wxImage *) &_result_ref;
13785 }
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13790 return resultobj;
13791 fail:
13792 return NULL;
13793 }
13794
13795
13796 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13797 PyObject *resultobj = 0;
13798 wxImage *arg1 = (wxImage *) 0 ;
13799 wxSize *arg2 = 0 ;
13800 wxPoint *arg3 = 0 ;
13801 int arg4 = (int) -1 ;
13802 int arg5 = (int) -1 ;
13803 int arg6 = (int) -1 ;
13804 wxImage *result = 0 ;
13805 void *argp1 = 0 ;
13806 int res1 = 0 ;
13807 wxSize temp2 ;
13808 wxPoint temp3 ;
13809 int val4 ;
13810 int ecode4 = 0 ;
13811 int val5 ;
13812 int ecode5 = 0 ;
13813 int val6 ;
13814 int ecode6 = 0 ;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 PyObject * obj3 = 0 ;
13819 PyObject * obj4 = 0 ;
13820 PyObject * obj5 = 0 ;
13821 char * kwnames[] = {
13822 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13823 };
13824
13825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13827 if (!SWIG_IsOK(res1)) {
13828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13829 }
13830 arg1 = reinterpret_cast< wxImage * >(argp1);
13831 {
13832 arg2 = &temp2;
13833 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13834 }
13835 {
13836 arg3 = &temp3;
13837 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13838 }
13839 if (obj3) {
13840 ecode4 = SWIG_AsVal_int(obj3, &val4);
13841 if (!SWIG_IsOK(ecode4)) {
13842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13843 }
13844 arg4 = static_cast< int >(val4);
13845 }
13846 if (obj4) {
13847 ecode5 = SWIG_AsVal_int(obj4, &val5);
13848 if (!SWIG_IsOK(ecode5)) {
13849 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13850 }
13851 arg5 = static_cast< int >(val5);
13852 }
13853 if (obj5) {
13854 ecode6 = SWIG_AsVal_int(obj5, &val6);
13855 if (!SWIG_IsOK(ecode6)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13857 }
13858 arg6 = static_cast< int >(val6);
13859 }
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 {
13863 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13864 result = (wxImage *) &_result_ref;
13865 }
13866 wxPyEndAllowThreads(__tstate);
13867 if (PyErr_Occurred()) SWIG_fail;
13868 }
13869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13870 return resultobj;
13871 fail:
13872 return NULL;
13873 }
13874
13875
13876 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13877 PyObject *resultobj = 0;
13878 wxImage *arg1 = (wxImage *) 0 ;
13879 int arg2 ;
13880 int arg3 ;
13881 byte arg4 ;
13882 byte arg5 ;
13883 byte arg6 ;
13884 void *argp1 = 0 ;
13885 int res1 = 0 ;
13886 int val2 ;
13887 int ecode2 = 0 ;
13888 int val3 ;
13889 int ecode3 = 0 ;
13890 unsigned char val4 ;
13891 int ecode4 = 0 ;
13892 unsigned char val5 ;
13893 int ecode5 = 0 ;
13894 unsigned char val6 ;
13895 int ecode6 = 0 ;
13896 PyObject * obj0 = 0 ;
13897 PyObject * obj1 = 0 ;
13898 PyObject * obj2 = 0 ;
13899 PyObject * obj3 = 0 ;
13900 PyObject * obj4 = 0 ;
13901 PyObject * obj5 = 0 ;
13902 char * kwnames[] = {
13903 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13904 };
13905
13906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13908 if (!SWIG_IsOK(res1)) {
13909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13910 }
13911 arg1 = reinterpret_cast< wxImage * >(argp1);
13912 ecode2 = SWIG_AsVal_int(obj1, &val2);
13913 if (!SWIG_IsOK(ecode2)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13915 }
13916 arg2 = static_cast< int >(val2);
13917 ecode3 = SWIG_AsVal_int(obj2, &val3);
13918 if (!SWIG_IsOK(ecode3)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13920 }
13921 arg3 = static_cast< int >(val3);
13922 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13923 if (!SWIG_IsOK(ecode4)) {
13924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13925 }
13926 arg4 = static_cast< byte >(val4);
13927 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13928 if (!SWIG_IsOK(ecode5)) {
13929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13930 }
13931 arg5 = static_cast< byte >(val5);
13932 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13933 if (!SWIG_IsOK(ecode6)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13935 }
13936 arg6 = static_cast< byte >(val6);
13937 {
13938 PyThreadState* __tstate = wxPyBeginAllowThreads();
13939 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13940 wxPyEndAllowThreads(__tstate);
13941 if (PyErr_Occurred()) SWIG_fail;
13942 }
13943 resultobj = SWIG_Py_Void();
13944 return resultobj;
13945 fail:
13946 return NULL;
13947 }
13948
13949
13950 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13951 PyObject *resultobj = 0;
13952 wxImage *arg1 = (wxImage *) 0 ;
13953 wxRect *arg2 = 0 ;
13954 byte arg3 ;
13955 byte arg4 ;
13956 byte arg5 ;
13957 void *argp1 = 0 ;
13958 int res1 = 0 ;
13959 wxRect temp2 ;
13960 unsigned char val3 ;
13961 int ecode3 = 0 ;
13962 unsigned char val4 ;
13963 int ecode4 = 0 ;
13964 unsigned char val5 ;
13965 int ecode5 = 0 ;
13966 PyObject * obj0 = 0 ;
13967 PyObject * obj1 = 0 ;
13968 PyObject * obj2 = 0 ;
13969 PyObject * obj3 = 0 ;
13970 PyObject * obj4 = 0 ;
13971 char * kwnames[] = {
13972 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13973 };
13974
13975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13977 if (!SWIG_IsOK(res1)) {
13978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13979 }
13980 arg1 = reinterpret_cast< wxImage * >(argp1);
13981 {
13982 arg2 = &temp2;
13983 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13984 }
13985 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13986 if (!SWIG_IsOK(ecode3)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13988 }
13989 arg3 = static_cast< byte >(val3);
13990 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13991 if (!SWIG_IsOK(ecode4)) {
13992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13993 }
13994 arg4 = static_cast< byte >(val4);
13995 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13996 if (!SWIG_IsOK(ecode5)) {
13997 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13998 }
13999 arg5 = static_cast< byte >(val5);
14000 {
14001 PyThreadState* __tstate = wxPyBeginAllowThreads();
14002 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14003 wxPyEndAllowThreads(__tstate);
14004 if (PyErr_Occurred()) SWIG_fail;
14005 }
14006 resultobj = SWIG_Py_Void();
14007 return resultobj;
14008 fail:
14009 return NULL;
14010 }
14011
14012
14013 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14014 PyObject *resultobj = 0;
14015 wxImage *arg1 = (wxImage *) 0 ;
14016 int arg2 ;
14017 int arg3 ;
14018 byte result;
14019 void *argp1 = 0 ;
14020 int res1 = 0 ;
14021 int val2 ;
14022 int ecode2 = 0 ;
14023 int val3 ;
14024 int ecode3 = 0 ;
14025 PyObject * obj0 = 0 ;
14026 PyObject * obj1 = 0 ;
14027 PyObject * obj2 = 0 ;
14028 char * kwnames[] = {
14029 (char *) "self",(char *) "x",(char *) "y", NULL
14030 };
14031
14032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14034 if (!SWIG_IsOK(res1)) {
14035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14036 }
14037 arg1 = reinterpret_cast< wxImage * >(argp1);
14038 ecode2 = SWIG_AsVal_int(obj1, &val2);
14039 if (!SWIG_IsOK(ecode2)) {
14040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14041 }
14042 arg2 = static_cast< int >(val2);
14043 ecode3 = SWIG_AsVal_int(obj2, &val3);
14044 if (!SWIG_IsOK(ecode3)) {
14045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14046 }
14047 arg3 = static_cast< int >(val3);
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 result = (byte)(arg1)->GetRed(arg2,arg3);
14051 wxPyEndAllowThreads(__tstate);
14052 if (PyErr_Occurred()) SWIG_fail;
14053 }
14054 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14055 return resultobj;
14056 fail:
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14062 PyObject *resultobj = 0;
14063 wxImage *arg1 = (wxImage *) 0 ;
14064 int arg2 ;
14065 int arg3 ;
14066 byte result;
14067 void *argp1 = 0 ;
14068 int res1 = 0 ;
14069 int val2 ;
14070 int ecode2 = 0 ;
14071 int val3 ;
14072 int ecode3 = 0 ;
14073 PyObject * obj0 = 0 ;
14074 PyObject * obj1 = 0 ;
14075 PyObject * obj2 = 0 ;
14076 char * kwnames[] = {
14077 (char *) "self",(char *) "x",(char *) "y", NULL
14078 };
14079
14080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14082 if (!SWIG_IsOK(res1)) {
14083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14084 }
14085 arg1 = reinterpret_cast< wxImage * >(argp1);
14086 ecode2 = SWIG_AsVal_int(obj1, &val2);
14087 if (!SWIG_IsOK(ecode2)) {
14088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14089 }
14090 arg2 = static_cast< int >(val2);
14091 ecode3 = SWIG_AsVal_int(obj2, &val3);
14092 if (!SWIG_IsOK(ecode3)) {
14093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14094 }
14095 arg3 = static_cast< int >(val3);
14096 {
14097 PyThreadState* __tstate = wxPyBeginAllowThreads();
14098 result = (byte)(arg1)->GetGreen(arg2,arg3);
14099 wxPyEndAllowThreads(__tstate);
14100 if (PyErr_Occurred()) SWIG_fail;
14101 }
14102 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14103 return resultobj;
14104 fail:
14105 return NULL;
14106 }
14107
14108
14109 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14110 PyObject *resultobj = 0;
14111 wxImage *arg1 = (wxImage *) 0 ;
14112 int arg2 ;
14113 int arg3 ;
14114 byte result;
14115 void *argp1 = 0 ;
14116 int res1 = 0 ;
14117 int val2 ;
14118 int ecode2 = 0 ;
14119 int val3 ;
14120 int ecode3 = 0 ;
14121 PyObject * obj0 = 0 ;
14122 PyObject * obj1 = 0 ;
14123 PyObject * obj2 = 0 ;
14124 char * kwnames[] = {
14125 (char *) "self",(char *) "x",(char *) "y", NULL
14126 };
14127
14128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14130 if (!SWIG_IsOK(res1)) {
14131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14132 }
14133 arg1 = reinterpret_cast< wxImage * >(argp1);
14134 ecode2 = SWIG_AsVal_int(obj1, &val2);
14135 if (!SWIG_IsOK(ecode2)) {
14136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14137 }
14138 arg2 = static_cast< int >(val2);
14139 ecode3 = SWIG_AsVal_int(obj2, &val3);
14140 if (!SWIG_IsOK(ecode3)) {
14141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14142 }
14143 arg3 = static_cast< int >(val3);
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 result = (byte)(arg1)->GetBlue(arg2,arg3);
14147 wxPyEndAllowThreads(__tstate);
14148 if (PyErr_Occurred()) SWIG_fail;
14149 }
14150 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14151 return resultobj;
14152 fail:
14153 return NULL;
14154 }
14155
14156
14157 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14158 PyObject *resultobj = 0;
14159 wxImage *arg1 = (wxImage *) 0 ;
14160 int arg2 ;
14161 int arg3 ;
14162 byte arg4 ;
14163 void *argp1 = 0 ;
14164 int res1 = 0 ;
14165 int val2 ;
14166 int ecode2 = 0 ;
14167 int val3 ;
14168 int ecode3 = 0 ;
14169 unsigned char val4 ;
14170 int ecode4 = 0 ;
14171 PyObject * obj0 = 0 ;
14172 PyObject * obj1 = 0 ;
14173 PyObject * obj2 = 0 ;
14174 PyObject * obj3 = 0 ;
14175 char * kwnames[] = {
14176 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14177 };
14178
14179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",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_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14183 }
14184 arg1 = reinterpret_cast< wxImage * >(argp1);
14185 ecode2 = SWIG_AsVal_int(obj1, &val2);
14186 if (!SWIG_IsOK(ecode2)) {
14187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14188 }
14189 arg2 = static_cast< int >(val2);
14190 ecode3 = SWIG_AsVal_int(obj2, &val3);
14191 if (!SWIG_IsOK(ecode3)) {
14192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14193 }
14194 arg3 = static_cast< int >(val3);
14195 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14196 if (!SWIG_IsOK(ecode4)) {
14197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14198 }
14199 arg4 = static_cast< byte >(val4);
14200 {
14201 PyThreadState* __tstate = wxPyBeginAllowThreads();
14202 (arg1)->SetAlpha(arg2,arg3,arg4);
14203 wxPyEndAllowThreads(__tstate);
14204 if (PyErr_Occurred()) SWIG_fail;
14205 }
14206 resultobj = SWIG_Py_Void();
14207 return resultobj;
14208 fail:
14209 return NULL;
14210 }
14211
14212
14213 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14214 PyObject *resultobj = 0;
14215 wxImage *arg1 = (wxImage *) 0 ;
14216 int arg2 ;
14217 int arg3 ;
14218 byte result;
14219 void *argp1 = 0 ;
14220 int res1 = 0 ;
14221 int val2 ;
14222 int ecode2 = 0 ;
14223 int val3 ;
14224 int ecode3 = 0 ;
14225 PyObject * obj0 = 0 ;
14226 PyObject * obj1 = 0 ;
14227 PyObject * obj2 = 0 ;
14228 char * kwnames[] = {
14229 (char *) "self",(char *) "x",(char *) "y", NULL
14230 };
14231
14232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14234 if (!SWIG_IsOK(res1)) {
14235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14236 }
14237 arg1 = reinterpret_cast< wxImage * >(argp1);
14238 ecode2 = SWIG_AsVal_int(obj1, &val2);
14239 if (!SWIG_IsOK(ecode2)) {
14240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14241 }
14242 arg2 = static_cast< int >(val2);
14243 ecode3 = SWIG_AsVal_int(obj2, &val3);
14244 if (!SWIG_IsOK(ecode3)) {
14245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14246 }
14247 arg3 = static_cast< int >(val3);
14248 {
14249 PyThreadState* __tstate = wxPyBeginAllowThreads();
14250 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14262 PyObject *resultobj = 0;
14263 wxImage *arg1 = (wxImage *) 0 ;
14264 bool result;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 PyObject *swig_obj[1] ;
14268
14269 if (!args) SWIG_fail;
14270 swig_obj[0] = args;
14271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14272 if (!SWIG_IsOK(res1)) {
14273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14274 }
14275 arg1 = reinterpret_cast< wxImage * >(argp1);
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 result = (bool)(arg1)->HasAlpha();
14279 wxPyEndAllowThreads(__tstate);
14280 if (PyErr_Occurred()) SWIG_fail;
14281 }
14282 {
14283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14284 }
14285 return resultobj;
14286 fail:
14287 return NULL;
14288 }
14289
14290
14291 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14292 PyObject *resultobj = 0;
14293 wxImage *arg1 = (wxImage *) 0 ;
14294 void *argp1 = 0 ;
14295 int res1 = 0 ;
14296 PyObject *swig_obj[1] ;
14297
14298 if (!args) SWIG_fail;
14299 swig_obj[0] = args;
14300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14301 if (!SWIG_IsOK(res1)) {
14302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14303 }
14304 arg1 = reinterpret_cast< wxImage * >(argp1);
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 (arg1)->InitAlpha();
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 resultobj = SWIG_Py_Void();
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14319 PyObject *resultobj = 0;
14320 wxImage *arg1 = (wxImage *) 0 ;
14321 int arg2 ;
14322 int arg3 ;
14323 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14324 bool result;
14325 void *argp1 = 0 ;
14326 int res1 = 0 ;
14327 int val2 ;
14328 int ecode2 = 0 ;
14329 int val3 ;
14330 int ecode3 = 0 ;
14331 unsigned char val4 ;
14332 int ecode4 = 0 ;
14333 PyObject * obj0 = 0 ;
14334 PyObject * obj1 = 0 ;
14335 PyObject * obj2 = 0 ;
14336 PyObject * obj3 = 0 ;
14337 char * kwnames[] = {
14338 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14339 };
14340
14341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14343 if (!SWIG_IsOK(res1)) {
14344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14345 }
14346 arg1 = reinterpret_cast< wxImage * >(argp1);
14347 ecode2 = SWIG_AsVal_int(obj1, &val2);
14348 if (!SWIG_IsOK(ecode2)) {
14349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14350 }
14351 arg2 = static_cast< int >(val2);
14352 ecode3 = SWIG_AsVal_int(obj2, &val3);
14353 if (!SWIG_IsOK(ecode3)) {
14354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14355 }
14356 arg3 = static_cast< int >(val3);
14357 if (obj3) {
14358 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14359 if (!SWIG_IsOK(ecode4)) {
14360 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14361 }
14362 arg4 = static_cast< byte >(val4);
14363 }
14364 {
14365 PyThreadState* __tstate = wxPyBeginAllowThreads();
14366 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14367 wxPyEndAllowThreads(__tstate);
14368 if (PyErr_Occurred()) SWIG_fail;
14369 }
14370 {
14371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14372 }
14373 return resultobj;
14374 fail:
14375 return NULL;
14376 }
14377
14378
14379 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14380 PyObject *resultobj = 0;
14381 wxImage *arg1 = (wxImage *) 0 ;
14382 byte *arg2 = (byte *) 0 ;
14383 byte *arg3 = (byte *) 0 ;
14384 byte *arg4 = (byte *) 0 ;
14385 byte arg5 = (byte) 0 ;
14386 byte arg6 = (byte) 0 ;
14387 byte arg7 = (byte) 0 ;
14388 bool result;
14389 void *argp1 = 0 ;
14390 int res1 = 0 ;
14391 byte temp2 ;
14392 int res2 = SWIG_TMPOBJ ;
14393 byte temp3 ;
14394 int res3 = SWIG_TMPOBJ ;
14395 byte temp4 ;
14396 int res4 = SWIG_TMPOBJ ;
14397 unsigned char val5 ;
14398 int ecode5 = 0 ;
14399 unsigned char val6 ;
14400 int ecode6 = 0 ;
14401 unsigned char val7 ;
14402 int ecode7 = 0 ;
14403 PyObject * obj0 = 0 ;
14404 PyObject * obj1 = 0 ;
14405 PyObject * obj2 = 0 ;
14406 PyObject * obj3 = 0 ;
14407 char * kwnames[] = {
14408 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14409 };
14410
14411 arg2 = &temp2;
14412 arg3 = &temp3;
14413 arg4 = &temp4;
14414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14416 if (!SWIG_IsOK(res1)) {
14417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14418 }
14419 arg1 = reinterpret_cast< wxImage * >(argp1);
14420 if (obj1) {
14421 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14422 if (!SWIG_IsOK(ecode5)) {
14423 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14424 }
14425 arg5 = static_cast< byte >(val5);
14426 }
14427 if (obj2) {
14428 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14429 if (!SWIG_IsOK(ecode6)) {
14430 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14431 }
14432 arg6 = static_cast< byte >(val6);
14433 }
14434 if (obj3) {
14435 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14436 if (!SWIG_IsOK(ecode7)) {
14437 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14438 }
14439 arg7 = static_cast< byte >(val7);
14440 }
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 {
14448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14449 }
14450 if (SWIG_IsTmpObj(res2)) {
14451 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14452 } else {
14453 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14455 }
14456 if (SWIG_IsTmpObj(res3)) {
14457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14458 } else {
14459 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14461 }
14462 if (SWIG_IsTmpObj(res4)) {
14463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14464 } else {
14465 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14467 }
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj = 0;
14476 wxImage *arg1 = (wxImage *) 0 ;
14477 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14478 bool result;
14479 void *argp1 = 0 ;
14480 int res1 = 0 ;
14481 unsigned char val2 ;
14482 int ecode2 = 0 ;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 char * kwnames[] = {
14486 (char *) "self",(char *) "threshold", NULL
14487 };
14488
14489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14493 }
14494 arg1 = reinterpret_cast< wxImage * >(argp1);
14495 if (obj1) {
14496 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14497 if (!SWIG_IsOK(ecode2)) {
14498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14499 }
14500 arg2 = static_cast< byte >(val2);
14501 }
14502 {
14503 PyThreadState* __tstate = wxPyBeginAllowThreads();
14504 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14518 PyObject *resultobj = 0;
14519 wxImage *arg1 = (wxImage *) 0 ;
14520 byte arg2 ;
14521 byte arg3 ;
14522 byte arg4 ;
14523 bool result;
14524 void *argp1 = 0 ;
14525 int res1 = 0 ;
14526 unsigned char val2 ;
14527 int ecode2 = 0 ;
14528 unsigned char val3 ;
14529 int ecode3 = 0 ;
14530 unsigned char val4 ;
14531 int ecode4 = 0 ;
14532 PyObject * obj0 = 0 ;
14533 PyObject * obj1 = 0 ;
14534 PyObject * obj2 = 0 ;
14535 PyObject * obj3 = 0 ;
14536 char * kwnames[] = {
14537 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14538 };
14539
14540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14542 if (!SWIG_IsOK(res1)) {
14543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14544 }
14545 arg1 = reinterpret_cast< wxImage * >(argp1);
14546 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14547 if (!SWIG_IsOK(ecode2)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14549 }
14550 arg2 = static_cast< byte >(val2);
14551 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14552 if (!SWIG_IsOK(ecode3)) {
14553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14554 }
14555 arg3 = static_cast< byte >(val3);
14556 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14557 if (!SWIG_IsOK(ecode4)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14559 }
14560 arg4 = static_cast< byte >(val4);
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 {
14568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14569 }
14570 return resultobj;
14571 fail:
14572 return NULL;
14573 }
14574
14575
14576 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14577 PyObject *resultobj = 0;
14578 wxImage *arg1 = (wxImage *) 0 ;
14579 wxImage *arg2 = 0 ;
14580 byte arg3 ;
14581 byte arg4 ;
14582 byte arg5 ;
14583 bool result;
14584 void *argp1 = 0 ;
14585 int res1 = 0 ;
14586 void *argp2 = 0 ;
14587 int res2 = 0 ;
14588 unsigned char val3 ;
14589 int ecode3 = 0 ;
14590 unsigned char val4 ;
14591 int ecode4 = 0 ;
14592 unsigned char val5 ;
14593 int ecode5 = 0 ;
14594 PyObject * obj0 = 0 ;
14595 PyObject * obj1 = 0 ;
14596 PyObject * obj2 = 0 ;
14597 PyObject * obj3 = 0 ;
14598 PyObject * obj4 = 0 ;
14599 char * kwnames[] = {
14600 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14601 };
14602
14603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14605 if (!SWIG_IsOK(res1)) {
14606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14607 }
14608 arg1 = reinterpret_cast< wxImage * >(argp1);
14609 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14610 if (!SWIG_IsOK(res2)) {
14611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14612 }
14613 if (!argp2) {
14614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14615 }
14616 arg2 = reinterpret_cast< wxImage * >(argp2);
14617 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14618 if (!SWIG_IsOK(ecode3)) {
14619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14620 }
14621 arg3 = static_cast< byte >(val3);
14622 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14623 if (!SWIG_IsOK(ecode4)) {
14624 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14625 }
14626 arg4 = static_cast< byte >(val4);
14627 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14628 if (!SWIG_IsOK(ecode5)) {
14629 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14630 }
14631 arg5 = static_cast< byte >(val5);
14632 {
14633 PyThreadState* __tstate = wxPyBeginAllowThreads();
14634 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14635 wxPyEndAllowThreads(__tstate);
14636 if (PyErr_Occurred()) SWIG_fail;
14637 }
14638 {
14639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14640 }
14641 return resultobj;
14642 fail:
14643 return NULL;
14644 }
14645
14646
14647 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14648 PyObject *resultobj = 0;
14649 wxString *arg1 = 0 ;
14650 bool result;
14651 bool temp1 = false ;
14652 PyObject * obj0 = 0 ;
14653 char * kwnames[] = {
14654 (char *) "filename", NULL
14655 };
14656
14657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14658 {
14659 arg1 = wxString_in_helper(obj0);
14660 if (arg1 == NULL) SWIG_fail;
14661 temp1 = true;
14662 }
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14666 wxPyEndAllowThreads(__tstate);
14667 if (PyErr_Occurred()) SWIG_fail;
14668 }
14669 {
14670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14671 }
14672 {
14673 if (temp1)
14674 delete arg1;
14675 }
14676 return resultobj;
14677 fail:
14678 {
14679 if (temp1)
14680 delete arg1;
14681 }
14682 return NULL;
14683 }
14684
14685
14686 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14687 PyObject *resultobj = 0;
14688 wxString *arg1 = 0 ;
14689 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14690 int result;
14691 bool temp1 = false ;
14692 long val2 ;
14693 int ecode2 = 0 ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 char * kwnames[] = {
14697 (char *) "filename",(char *) "type", NULL
14698 };
14699
14700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14701 {
14702 arg1 = wxString_in_helper(obj0);
14703 if (arg1 == NULL) SWIG_fail;
14704 temp1 = true;
14705 }
14706 if (obj1) {
14707 ecode2 = SWIG_AsVal_long(obj1, &val2);
14708 if (!SWIG_IsOK(ecode2)) {
14709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14710 }
14711 arg2 = static_cast< long >(val2);
14712 }
14713 {
14714 PyThreadState* __tstate = wxPyBeginAllowThreads();
14715 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14716 wxPyEndAllowThreads(__tstate);
14717 if (PyErr_Occurred()) SWIG_fail;
14718 }
14719 resultobj = SWIG_From_int(static_cast< int >(result));
14720 {
14721 if (temp1)
14722 delete arg1;
14723 }
14724 return resultobj;
14725 fail:
14726 {
14727 if (temp1)
14728 delete arg1;
14729 }
14730 return NULL;
14731 }
14732
14733
14734 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14735 PyObject *resultobj = 0;
14736 wxImage *arg1 = (wxImage *) 0 ;
14737 wxString *arg2 = 0 ;
14738 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14739 int arg4 = (int) -1 ;
14740 bool result;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 bool temp2 = false ;
14744 long val3 ;
14745 int ecode3 = 0 ;
14746 int val4 ;
14747 int ecode4 = 0 ;
14748 PyObject * obj0 = 0 ;
14749 PyObject * obj1 = 0 ;
14750 PyObject * obj2 = 0 ;
14751 PyObject * obj3 = 0 ;
14752 char * kwnames[] = {
14753 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14754 };
14755
14756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14758 if (!SWIG_IsOK(res1)) {
14759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14760 }
14761 arg1 = reinterpret_cast< wxImage * >(argp1);
14762 {
14763 arg2 = wxString_in_helper(obj1);
14764 if (arg2 == NULL) SWIG_fail;
14765 temp2 = true;
14766 }
14767 if (obj2) {
14768 ecode3 = SWIG_AsVal_long(obj2, &val3);
14769 if (!SWIG_IsOK(ecode3)) {
14770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14771 }
14772 arg3 = static_cast< long >(val3);
14773 }
14774 if (obj3) {
14775 ecode4 = SWIG_AsVal_int(obj3, &val4);
14776 if (!SWIG_IsOK(ecode4)) {
14777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14778 }
14779 arg4 = static_cast< int >(val4);
14780 }
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 {
14788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14789 }
14790 {
14791 if (temp2)
14792 delete arg2;
14793 }
14794 return resultobj;
14795 fail:
14796 {
14797 if (temp2)
14798 delete arg2;
14799 }
14800 return NULL;
14801 }
14802
14803
14804 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj = 0;
14806 wxImage *arg1 = (wxImage *) 0 ;
14807 wxString *arg2 = 0 ;
14808 wxString *arg3 = 0 ;
14809 int arg4 = (int) -1 ;
14810 bool result;
14811 void *argp1 = 0 ;
14812 int res1 = 0 ;
14813 bool temp2 = false ;
14814 bool temp3 = false ;
14815 int val4 ;
14816 int ecode4 = 0 ;
14817 PyObject * obj0 = 0 ;
14818 PyObject * obj1 = 0 ;
14819 PyObject * obj2 = 0 ;
14820 PyObject * obj3 = 0 ;
14821 char * kwnames[] = {
14822 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14823 };
14824
14825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14829 }
14830 arg1 = reinterpret_cast< wxImage * >(argp1);
14831 {
14832 arg2 = wxString_in_helper(obj1);
14833 if (arg2 == NULL) SWIG_fail;
14834 temp2 = true;
14835 }
14836 {
14837 arg3 = wxString_in_helper(obj2);
14838 if (arg3 == NULL) SWIG_fail;
14839 temp3 = true;
14840 }
14841 if (obj3) {
14842 ecode4 = SWIG_AsVal_int(obj3, &val4);
14843 if (!SWIG_IsOK(ecode4)) {
14844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14845 }
14846 arg4 = static_cast< int >(val4);
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14851 wxPyEndAllowThreads(__tstate);
14852 if (PyErr_Occurred()) SWIG_fail;
14853 }
14854 {
14855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14856 }
14857 {
14858 if (temp2)
14859 delete arg2;
14860 }
14861 {
14862 if (temp3)
14863 delete arg3;
14864 }
14865 return resultobj;
14866 fail:
14867 {
14868 if (temp2)
14869 delete arg2;
14870 }
14871 {
14872 if (temp3)
14873 delete arg3;
14874 }
14875 return NULL;
14876 }
14877
14878
14879 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14880 PyObject *resultobj = 0;
14881 wxImage *arg1 = (wxImage *) 0 ;
14882 wxString *arg2 = 0 ;
14883 int arg3 ;
14884 bool result;
14885 void *argp1 = 0 ;
14886 int res1 = 0 ;
14887 bool temp2 = false ;
14888 int val3 ;
14889 int ecode3 = 0 ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 PyObject * obj2 = 0 ;
14893 char * kwnames[] = {
14894 (char *) "self",(char *) "name",(char *) "type", NULL
14895 };
14896
14897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14899 if (!SWIG_IsOK(res1)) {
14900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14901 }
14902 arg1 = reinterpret_cast< wxImage * >(argp1);
14903 {
14904 arg2 = wxString_in_helper(obj1);
14905 if (arg2 == NULL) SWIG_fail;
14906 temp2 = true;
14907 }
14908 ecode3 = SWIG_AsVal_int(obj2, &val3);
14909 if (!SWIG_IsOK(ecode3)) {
14910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14911 }
14912 arg3 = static_cast< int >(val3);
14913 {
14914 PyThreadState* __tstate = wxPyBeginAllowThreads();
14915 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14916 wxPyEndAllowThreads(__tstate);
14917 if (PyErr_Occurred()) SWIG_fail;
14918 }
14919 {
14920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14921 }
14922 {
14923 if (temp2)
14924 delete arg2;
14925 }
14926 return resultobj;
14927 fail:
14928 {
14929 if (temp2)
14930 delete arg2;
14931 }
14932 return NULL;
14933 }
14934
14935
14936 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14937 PyObject *resultobj = 0;
14938 wxImage *arg1 = (wxImage *) 0 ;
14939 wxString *arg2 = 0 ;
14940 wxString *arg3 = 0 ;
14941 bool result;
14942 void *argp1 = 0 ;
14943 int res1 = 0 ;
14944 bool temp2 = false ;
14945 bool temp3 = false ;
14946 PyObject * obj0 = 0 ;
14947 PyObject * obj1 = 0 ;
14948 PyObject * obj2 = 0 ;
14949 char * kwnames[] = {
14950 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14951 };
14952
14953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14955 if (!SWIG_IsOK(res1)) {
14956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14957 }
14958 arg1 = reinterpret_cast< wxImage * >(argp1);
14959 {
14960 arg2 = wxString_in_helper(obj1);
14961 if (arg2 == NULL) SWIG_fail;
14962 temp2 = true;
14963 }
14964 {
14965 arg3 = wxString_in_helper(obj2);
14966 if (arg3 == NULL) SWIG_fail;
14967 temp3 = true;
14968 }
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 {
14976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14977 }
14978 {
14979 if (temp2)
14980 delete arg2;
14981 }
14982 {
14983 if (temp3)
14984 delete arg3;
14985 }
14986 return resultobj;
14987 fail:
14988 {
14989 if (temp2)
14990 delete arg2;
14991 }
14992 {
14993 if (temp3)
14994 delete arg3;
14995 }
14996 return NULL;
14997 }
14998
14999
15000 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15001 PyObject *resultobj = 0;
15002 wxInputStream *arg1 = 0 ;
15003 bool result;
15004 wxPyInputStream *temp1 ;
15005 bool created1 ;
15006 PyObject * obj0 = 0 ;
15007 char * kwnames[] = {
15008 (char *) "stream", NULL
15009 };
15010
15011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15012 {
15013 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15014 arg1 = temp1->m_wxis;
15015 created1 = false;
15016 } else {
15017 PyErr_Clear(); // clear the failure of the wxPyConvert above
15018 arg1 = wxPyCBInputStream_create(obj0, false);
15019 if (arg1 == NULL) {
15020 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15021 SWIG_fail;
15022 }
15023 created1 = true;
15024 }
15025 }
15026 {
15027 PyThreadState* __tstate = wxPyBeginAllowThreads();
15028 result = (bool)wxImage::CanRead(*arg1);
15029 wxPyEndAllowThreads(__tstate);
15030 if (PyErr_Occurred()) SWIG_fail;
15031 }
15032 {
15033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15034 }
15035 {
15036 if (created1) delete arg1;
15037 }
15038 return resultobj;
15039 fail:
15040 {
15041 if (created1) delete arg1;
15042 }
15043 return NULL;
15044 }
15045
15046
15047 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15048 PyObject *resultobj = 0;
15049 wxImage *arg1 = (wxImage *) 0 ;
15050 wxInputStream *arg2 = 0 ;
15051 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15052 int arg4 = (int) -1 ;
15053 bool result;
15054 void *argp1 = 0 ;
15055 int res1 = 0 ;
15056 wxPyInputStream *temp2 ;
15057 bool created2 ;
15058 long val3 ;
15059 int ecode3 = 0 ;
15060 int val4 ;
15061 int ecode4 = 0 ;
15062 PyObject * obj0 = 0 ;
15063 PyObject * obj1 = 0 ;
15064 PyObject * obj2 = 0 ;
15065 PyObject * obj3 = 0 ;
15066 char * kwnames[] = {
15067 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15068 };
15069
15070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15072 if (!SWIG_IsOK(res1)) {
15073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15074 }
15075 arg1 = reinterpret_cast< wxImage * >(argp1);
15076 {
15077 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15078 arg2 = temp2->m_wxis;
15079 created2 = false;
15080 } else {
15081 PyErr_Clear(); // clear the failure of the wxPyConvert above
15082 arg2 = wxPyCBInputStream_create(obj1, false);
15083 if (arg2 == NULL) {
15084 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15085 SWIG_fail;
15086 }
15087 created2 = true;
15088 }
15089 }
15090 if (obj2) {
15091 ecode3 = SWIG_AsVal_long(obj2, &val3);
15092 if (!SWIG_IsOK(ecode3)) {
15093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15094 }
15095 arg3 = static_cast< long >(val3);
15096 }
15097 if (obj3) {
15098 ecode4 = SWIG_AsVal_int(obj3, &val4);
15099 if (!SWIG_IsOK(ecode4)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15101 }
15102 arg4 = static_cast< int >(val4);
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 {
15111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15112 }
15113 {
15114 if (created2) delete arg2;
15115 }
15116 return resultobj;
15117 fail:
15118 {
15119 if (created2) delete arg2;
15120 }
15121 return NULL;
15122 }
15123
15124
15125 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15126 PyObject *resultobj = 0;
15127 wxImage *arg1 = (wxImage *) 0 ;
15128 wxInputStream *arg2 = 0 ;
15129 wxString *arg3 = 0 ;
15130 int arg4 = (int) -1 ;
15131 bool result;
15132 void *argp1 = 0 ;
15133 int res1 = 0 ;
15134 wxPyInputStream *temp2 ;
15135 bool created2 ;
15136 bool temp3 = false ;
15137 int val4 ;
15138 int ecode4 = 0 ;
15139 PyObject * obj0 = 0 ;
15140 PyObject * obj1 = 0 ;
15141 PyObject * obj2 = 0 ;
15142 PyObject * obj3 = 0 ;
15143 char * kwnames[] = {
15144 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15145 };
15146
15147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15149 if (!SWIG_IsOK(res1)) {
15150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15151 }
15152 arg1 = reinterpret_cast< wxImage * >(argp1);
15153 {
15154 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15155 arg2 = temp2->m_wxis;
15156 created2 = false;
15157 } else {
15158 PyErr_Clear(); // clear the failure of the wxPyConvert above
15159 arg2 = wxPyCBInputStream_create(obj1, false);
15160 if (arg2 == NULL) {
15161 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15162 SWIG_fail;
15163 }
15164 created2 = true;
15165 }
15166 }
15167 {
15168 arg3 = wxString_in_helper(obj2);
15169 if (arg3 == NULL) SWIG_fail;
15170 temp3 = true;
15171 }
15172 if (obj3) {
15173 ecode4 = SWIG_AsVal_int(obj3, &val4);
15174 if (!SWIG_IsOK(ecode4)) {
15175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15176 }
15177 arg4 = static_cast< int >(val4);
15178 }
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 {
15186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15187 }
15188 {
15189 if (created2) delete arg2;
15190 }
15191 {
15192 if (temp3)
15193 delete arg3;
15194 }
15195 return resultobj;
15196 fail:
15197 {
15198 if (created2) delete arg2;
15199 }
15200 {
15201 if (temp3)
15202 delete arg3;
15203 }
15204 return NULL;
15205 }
15206
15207
15208 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15209 PyObject *resultobj = 0;
15210 wxImage *arg1 = (wxImage *) 0 ;
15211 bool result;
15212 void *argp1 = 0 ;
15213 int res1 = 0 ;
15214 PyObject *swig_obj[1] ;
15215
15216 if (!args) SWIG_fail;
15217 swig_obj[0] = args;
15218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15219 if (!SWIG_IsOK(res1)) {
15220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15221 }
15222 arg1 = reinterpret_cast< wxImage * >(argp1);
15223 {
15224 PyThreadState* __tstate = wxPyBeginAllowThreads();
15225 result = (bool)(arg1)->Ok();
15226 wxPyEndAllowThreads(__tstate);
15227 if (PyErr_Occurred()) SWIG_fail;
15228 }
15229 {
15230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15231 }
15232 return resultobj;
15233 fail:
15234 return NULL;
15235 }
15236
15237
15238 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15239 PyObject *resultobj = 0;
15240 wxImage *arg1 = (wxImage *) 0 ;
15241 int result;
15242 void *argp1 = 0 ;
15243 int res1 = 0 ;
15244 PyObject *swig_obj[1] ;
15245
15246 if (!args) SWIG_fail;
15247 swig_obj[0] = args;
15248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15249 if (!SWIG_IsOK(res1)) {
15250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15251 }
15252 arg1 = reinterpret_cast< wxImage * >(argp1);
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 result = (int)(arg1)->GetWidth();
15256 wxPyEndAllowThreads(__tstate);
15257 if (PyErr_Occurred()) SWIG_fail;
15258 }
15259 resultobj = SWIG_From_int(static_cast< int >(result));
15260 return resultobj;
15261 fail:
15262 return NULL;
15263 }
15264
15265
15266 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15267 PyObject *resultobj = 0;
15268 wxImage *arg1 = (wxImage *) 0 ;
15269 int result;
15270 void *argp1 = 0 ;
15271 int res1 = 0 ;
15272 PyObject *swig_obj[1] ;
15273
15274 if (!args) SWIG_fail;
15275 swig_obj[0] = args;
15276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15277 if (!SWIG_IsOK(res1)) {
15278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15279 }
15280 arg1 = reinterpret_cast< wxImage * >(argp1);
15281 {
15282 PyThreadState* __tstate = wxPyBeginAllowThreads();
15283 result = (int)(arg1)->GetHeight();
15284 wxPyEndAllowThreads(__tstate);
15285 if (PyErr_Occurred()) SWIG_fail;
15286 }
15287 resultobj = SWIG_From_int(static_cast< int >(result));
15288 return resultobj;
15289 fail:
15290 return NULL;
15291 }
15292
15293
15294 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15295 PyObject *resultobj = 0;
15296 wxImage *arg1 = (wxImage *) 0 ;
15297 wxSize result;
15298 void *argp1 = 0 ;
15299 int res1 = 0 ;
15300 PyObject *swig_obj[1] ;
15301
15302 if (!args) SWIG_fail;
15303 swig_obj[0] = args;
15304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15305 if (!SWIG_IsOK(res1)) {
15306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15307 }
15308 arg1 = reinterpret_cast< wxImage * >(argp1);
15309 {
15310 PyThreadState* __tstate = wxPyBeginAllowThreads();
15311 result = wxImage_GetSize(arg1);
15312 wxPyEndAllowThreads(__tstate);
15313 if (PyErr_Occurred()) SWIG_fail;
15314 }
15315 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15316 return resultobj;
15317 fail:
15318 return NULL;
15319 }
15320
15321
15322 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15323 PyObject *resultobj = 0;
15324 wxImage *arg1 = (wxImage *) 0 ;
15325 wxRect *arg2 = 0 ;
15326 SwigValueWrapper<wxImage > result;
15327 void *argp1 = 0 ;
15328 int res1 = 0 ;
15329 wxRect temp2 ;
15330 PyObject * obj0 = 0 ;
15331 PyObject * obj1 = 0 ;
15332 char * kwnames[] = {
15333 (char *) "self",(char *) "rect", NULL
15334 };
15335
15336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15338 if (!SWIG_IsOK(res1)) {
15339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15340 }
15341 arg1 = reinterpret_cast< wxImage * >(argp1);
15342 {
15343 arg2 = &temp2;
15344 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15345 }
15346 {
15347 PyThreadState* __tstate = wxPyBeginAllowThreads();
15348 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15349 wxPyEndAllowThreads(__tstate);
15350 if (PyErr_Occurred()) SWIG_fail;
15351 }
15352 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15353 return resultobj;
15354 fail:
15355 return NULL;
15356 }
15357
15358
15359 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15360 PyObject *resultobj = 0;
15361 wxImage *arg1 = (wxImage *) 0 ;
15362 wxSize *arg2 = 0 ;
15363 wxPoint *arg3 = 0 ;
15364 int arg4 = (int) -1 ;
15365 int arg5 = (int) -1 ;
15366 int arg6 = (int) -1 ;
15367 SwigValueWrapper<wxImage > result;
15368 void *argp1 = 0 ;
15369 int res1 = 0 ;
15370 wxSize temp2 ;
15371 wxPoint temp3 ;
15372 int val4 ;
15373 int ecode4 = 0 ;
15374 int val5 ;
15375 int ecode5 = 0 ;
15376 int val6 ;
15377 int ecode6 = 0 ;
15378 PyObject * obj0 = 0 ;
15379 PyObject * obj1 = 0 ;
15380 PyObject * obj2 = 0 ;
15381 PyObject * obj3 = 0 ;
15382 PyObject * obj4 = 0 ;
15383 PyObject * obj5 = 0 ;
15384 char * kwnames[] = {
15385 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15386 };
15387
15388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15390 if (!SWIG_IsOK(res1)) {
15391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15392 }
15393 arg1 = reinterpret_cast< wxImage * >(argp1);
15394 {
15395 arg2 = &temp2;
15396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15397 }
15398 {
15399 arg3 = &temp3;
15400 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15401 }
15402 if (obj3) {
15403 ecode4 = SWIG_AsVal_int(obj3, &val4);
15404 if (!SWIG_IsOK(ecode4)) {
15405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15406 }
15407 arg4 = static_cast< int >(val4);
15408 }
15409 if (obj4) {
15410 ecode5 = SWIG_AsVal_int(obj4, &val5);
15411 if (!SWIG_IsOK(ecode5)) {
15412 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15413 }
15414 arg5 = static_cast< int >(val5);
15415 }
15416 if (obj5) {
15417 ecode6 = SWIG_AsVal_int(obj5, &val6);
15418 if (!SWIG_IsOK(ecode6)) {
15419 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15420 }
15421 arg6 = static_cast< int >(val6);
15422 }
15423 {
15424 PyThreadState* __tstate = wxPyBeginAllowThreads();
15425 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15426 wxPyEndAllowThreads(__tstate);
15427 if (PyErr_Occurred()) SWIG_fail;
15428 }
15429 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15437 PyObject *resultobj = 0;
15438 wxImage *arg1 = (wxImage *) 0 ;
15439 SwigValueWrapper<wxImage > result;
15440 void *argp1 = 0 ;
15441 int res1 = 0 ;
15442 PyObject *swig_obj[1] ;
15443
15444 if (!args) SWIG_fail;
15445 swig_obj[0] = args;
15446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15447 if (!SWIG_IsOK(res1)) {
15448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15449 }
15450 arg1 = reinterpret_cast< wxImage * >(argp1);
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 result = (arg1)->Copy();
15454 wxPyEndAllowThreads(__tstate);
15455 if (PyErr_Occurred()) SWIG_fail;
15456 }
15457 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15465 PyObject *resultobj = 0;
15466 wxImage *arg1 = (wxImage *) 0 ;
15467 wxImage *arg2 = 0 ;
15468 int arg3 ;
15469 int arg4 ;
15470 void *argp1 = 0 ;
15471 int res1 = 0 ;
15472 void *argp2 = 0 ;
15473 int res2 = 0 ;
15474 int val3 ;
15475 int ecode3 = 0 ;
15476 int val4 ;
15477 int ecode4 = 0 ;
15478 PyObject * obj0 = 0 ;
15479 PyObject * obj1 = 0 ;
15480 PyObject * obj2 = 0 ;
15481 PyObject * obj3 = 0 ;
15482 char * kwnames[] = {
15483 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15484 };
15485
15486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15488 if (!SWIG_IsOK(res1)) {
15489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15490 }
15491 arg1 = reinterpret_cast< wxImage * >(argp1);
15492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15493 if (!SWIG_IsOK(res2)) {
15494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15495 }
15496 if (!argp2) {
15497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15498 }
15499 arg2 = reinterpret_cast< wxImage * >(argp2);
15500 ecode3 = SWIG_AsVal_int(obj2, &val3);
15501 if (!SWIG_IsOK(ecode3)) {
15502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15503 }
15504 arg3 = static_cast< int >(val3);
15505 ecode4 = SWIG_AsVal_int(obj3, &val4);
15506 if (!SWIG_IsOK(ecode4)) {
15507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15508 }
15509 arg4 = static_cast< int >(val4);
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 resultobj = SWIG_Py_Void();
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15524 PyObject *resultobj = 0;
15525 wxImage *arg1 = (wxImage *) 0 ;
15526 PyObject *result = 0 ;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 PyObject *swig_obj[1] ;
15530
15531 if (!args) SWIG_fail;
15532 swig_obj[0] = args;
15533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15534 if (!SWIG_IsOK(res1)) {
15535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15536 }
15537 arg1 = reinterpret_cast< wxImage * >(argp1);
15538 {
15539 PyThreadState* __tstate = wxPyBeginAllowThreads();
15540 result = (PyObject *)wxImage_GetData(arg1);
15541 wxPyEndAllowThreads(__tstate);
15542 if (PyErr_Occurred()) SWIG_fail;
15543 }
15544 resultobj = result;
15545 return resultobj;
15546 fail:
15547 return NULL;
15548 }
15549
15550
15551 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15552 PyObject *resultobj = 0;
15553 wxImage *arg1 = (wxImage *) 0 ;
15554 buffer arg2 ;
15555 int arg3 ;
15556 void *argp1 = 0 ;
15557 int res1 = 0 ;
15558 Py_ssize_t temp2 ;
15559 PyObject * obj0 = 0 ;
15560 PyObject * obj1 = 0 ;
15561 char * kwnames[] = {
15562 (char *) "self",(char *) "data", NULL
15563 };
15564
15565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15567 if (!SWIG_IsOK(res1)) {
15568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15569 }
15570 arg1 = reinterpret_cast< wxImage * >(argp1);
15571 {
15572 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15573 arg3 = (int)temp2;
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 wxImage_SetData(arg1,arg2,arg3);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_Py_Void();
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15589 PyObject *resultobj = 0;
15590 wxImage *arg1 = (wxImage *) 0 ;
15591 PyObject *result = 0 ;
15592 void *argp1 = 0 ;
15593 int res1 = 0 ;
15594 PyObject *swig_obj[1] ;
15595
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15601 }
15602 arg1 = reinterpret_cast< wxImage * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = result;
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj = 0;
15618 wxImage *arg1 = (wxImage *) 0 ;
15619 buffer arg2 ;
15620 int arg3 ;
15621 void *argp1 = 0 ;
15622 int res1 = 0 ;
15623 Py_ssize_t temp2 ;
15624 PyObject * obj0 = 0 ;
15625 PyObject * obj1 = 0 ;
15626 char * kwnames[] = {
15627 (char *) "self",(char *) "data", NULL
15628 };
15629
15630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15632 if (!SWIG_IsOK(res1)) {
15633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15634 }
15635 arg1 = reinterpret_cast< wxImage * >(argp1);
15636 {
15637 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15638 arg3 = (int)temp2;
15639 }
15640 {
15641 PyThreadState* __tstate = wxPyBeginAllowThreads();
15642 wxImage_SetDataBuffer(arg1,arg2,arg3);
15643 wxPyEndAllowThreads(__tstate);
15644 if (PyErr_Occurred()) SWIG_fail;
15645 }
15646 resultobj = SWIG_Py_Void();
15647 return resultobj;
15648 fail:
15649 return NULL;
15650 }
15651
15652
15653 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15654 PyObject *resultobj = 0;
15655 wxImage *arg1 = (wxImage *) 0 ;
15656 PyObject *result = 0 ;
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_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15666 }
15667 arg1 = reinterpret_cast< wxImage * >(argp1);
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 result = (PyObject *)wxImage_GetAlphaData(arg1);
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = result;
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj = 0;
15683 wxImage *arg1 = (wxImage *) 0 ;
15684 buffer arg2 ;
15685 int arg3 ;
15686 void *argp1 = 0 ;
15687 int res1 = 0 ;
15688 Py_ssize_t temp2 ;
15689 PyObject * obj0 = 0 ;
15690 PyObject * obj1 = 0 ;
15691 char * kwnames[] = {
15692 (char *) "self",(char *) "alpha", NULL
15693 };
15694
15695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15697 if (!SWIG_IsOK(res1)) {
15698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15699 }
15700 arg1 = reinterpret_cast< wxImage * >(argp1);
15701 {
15702 if (obj1 != Py_None) {
15703 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15704 arg3 = (int)temp2;
15705 }
15706 }
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 wxImage_SetAlphaData(arg1,arg2,arg3);
15710 wxPyEndAllowThreads(__tstate);
15711 if (PyErr_Occurred()) SWIG_fail;
15712 }
15713 resultobj = SWIG_Py_Void();
15714 return resultobj;
15715 fail:
15716 return NULL;
15717 }
15718
15719
15720 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15721 PyObject *resultobj = 0;
15722 wxImage *arg1 = (wxImage *) 0 ;
15723 PyObject *result = 0 ;
15724 void *argp1 = 0 ;
15725 int res1 = 0 ;
15726 PyObject *swig_obj[1] ;
15727
15728 if (!args) SWIG_fail;
15729 swig_obj[0] = args;
15730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15731 if (!SWIG_IsOK(res1)) {
15732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15733 }
15734 arg1 = reinterpret_cast< wxImage * >(argp1);
15735 {
15736 PyThreadState* __tstate = wxPyBeginAllowThreads();
15737 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 resultobj = result;
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj = 0;
15750 wxImage *arg1 = (wxImage *) 0 ;
15751 buffer arg2 ;
15752 int arg3 ;
15753 void *argp1 = 0 ;
15754 int res1 = 0 ;
15755 Py_ssize_t temp2 ;
15756 PyObject * obj0 = 0 ;
15757 PyObject * obj1 = 0 ;
15758 char * kwnames[] = {
15759 (char *) "self",(char *) "alpha", NULL
15760 };
15761
15762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15764 if (!SWIG_IsOK(res1)) {
15765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15766 }
15767 arg1 = reinterpret_cast< wxImage * >(argp1);
15768 {
15769 if (obj1 != Py_None) {
15770 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15771 arg3 = (int)temp2;
15772 }
15773 }
15774 {
15775 PyThreadState* __tstate = wxPyBeginAllowThreads();
15776 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15777 wxPyEndAllowThreads(__tstate);
15778 if (PyErr_Occurred()) SWIG_fail;
15779 }
15780 resultobj = SWIG_Py_Void();
15781 return resultobj;
15782 fail:
15783 return NULL;
15784 }
15785
15786
15787 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15788 PyObject *resultobj = 0;
15789 wxImage *arg1 = (wxImage *) 0 ;
15790 byte arg2 ;
15791 byte arg3 ;
15792 byte arg4 ;
15793 void *argp1 = 0 ;
15794 int res1 = 0 ;
15795 unsigned char val2 ;
15796 int ecode2 = 0 ;
15797 unsigned char val3 ;
15798 int ecode3 = 0 ;
15799 unsigned char val4 ;
15800 int ecode4 = 0 ;
15801 PyObject * obj0 = 0 ;
15802 PyObject * obj1 = 0 ;
15803 PyObject * obj2 = 0 ;
15804 PyObject * obj3 = 0 ;
15805 char * kwnames[] = {
15806 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15807 };
15808
15809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15811 if (!SWIG_IsOK(res1)) {
15812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15813 }
15814 arg1 = reinterpret_cast< wxImage * >(argp1);
15815 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15816 if (!SWIG_IsOK(ecode2)) {
15817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15818 }
15819 arg2 = static_cast< byte >(val2);
15820 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15821 if (!SWIG_IsOK(ecode3)) {
15822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15823 }
15824 arg3 = static_cast< byte >(val3);
15825 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15826 if (!SWIG_IsOK(ecode4)) {
15827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15828 }
15829 arg4 = static_cast< byte >(val4);
15830 {
15831 PyThreadState* __tstate = wxPyBeginAllowThreads();
15832 (arg1)->SetMaskColour(arg2,arg3,arg4);
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 resultobj = SWIG_Py_Void();
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15844 PyObject *resultobj = 0;
15845 wxImage *arg1 = (wxImage *) 0 ;
15846 byte *arg2 = (byte *) 0 ;
15847 byte *arg3 = (byte *) 0 ;
15848 byte *arg4 = (byte *) 0 ;
15849 void *argp1 = 0 ;
15850 int res1 = 0 ;
15851 byte temp2 ;
15852 int res2 = SWIG_TMPOBJ ;
15853 byte temp3 ;
15854 int res3 = SWIG_TMPOBJ ;
15855 byte temp4 ;
15856 int res4 = SWIG_TMPOBJ ;
15857 PyObject *swig_obj[1] ;
15858
15859 arg2 = &temp2;
15860 arg3 = &temp3;
15861 arg4 = &temp4;
15862 if (!args) SWIG_fail;
15863 swig_obj[0] = args;
15864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15865 if (!SWIG_IsOK(res1)) {
15866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15867 }
15868 arg1 = reinterpret_cast< wxImage * >(argp1);
15869 {
15870 PyThreadState* __tstate = wxPyBeginAllowThreads();
15871 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15872 wxPyEndAllowThreads(__tstate);
15873 if (PyErr_Occurred()) SWIG_fail;
15874 }
15875 resultobj = SWIG_Py_Void();
15876 if (SWIG_IsTmpObj(res2)) {
15877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15878 } else {
15879 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15881 }
15882 if (SWIG_IsTmpObj(res3)) {
15883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15884 } else {
15885 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15887 }
15888 if (SWIG_IsTmpObj(res4)) {
15889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15890 } else {
15891 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15893 }
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15901 PyObject *resultobj = 0;
15902 wxImage *arg1 = (wxImage *) 0 ;
15903 byte result;
15904 void *argp1 = 0 ;
15905 int res1 = 0 ;
15906 PyObject *swig_obj[1] ;
15907
15908 if (!args) SWIG_fail;
15909 swig_obj[0] = args;
15910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15911 if (!SWIG_IsOK(res1)) {
15912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15913 }
15914 arg1 = reinterpret_cast< wxImage * >(argp1);
15915 {
15916 PyThreadState* __tstate = wxPyBeginAllowThreads();
15917 result = (byte)(arg1)->GetMaskRed();
15918 wxPyEndAllowThreads(__tstate);
15919 if (PyErr_Occurred()) SWIG_fail;
15920 }
15921 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15922 return resultobj;
15923 fail:
15924 return NULL;
15925 }
15926
15927
15928 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15929 PyObject *resultobj = 0;
15930 wxImage *arg1 = (wxImage *) 0 ;
15931 byte result;
15932 void *argp1 = 0 ;
15933 int res1 = 0 ;
15934 PyObject *swig_obj[1] ;
15935
15936 if (!args) SWIG_fail;
15937 swig_obj[0] = args;
15938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15939 if (!SWIG_IsOK(res1)) {
15940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15941 }
15942 arg1 = reinterpret_cast< wxImage * >(argp1);
15943 {
15944 PyThreadState* __tstate = wxPyBeginAllowThreads();
15945 result = (byte)(arg1)->GetMaskGreen();
15946 wxPyEndAllowThreads(__tstate);
15947 if (PyErr_Occurred()) SWIG_fail;
15948 }
15949 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15950 return resultobj;
15951 fail:
15952 return NULL;
15953 }
15954
15955
15956 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15957 PyObject *resultobj = 0;
15958 wxImage *arg1 = (wxImage *) 0 ;
15959 byte result;
15960 void *argp1 = 0 ;
15961 int res1 = 0 ;
15962 PyObject *swig_obj[1] ;
15963
15964 if (!args) SWIG_fail;
15965 swig_obj[0] = args;
15966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15967 if (!SWIG_IsOK(res1)) {
15968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15969 }
15970 arg1 = reinterpret_cast< wxImage * >(argp1);
15971 {
15972 PyThreadState* __tstate = wxPyBeginAllowThreads();
15973 result = (byte)(arg1)->GetMaskBlue();
15974 wxPyEndAllowThreads(__tstate);
15975 if (PyErr_Occurred()) SWIG_fail;
15976 }
15977 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15978 return resultobj;
15979 fail:
15980 return NULL;
15981 }
15982
15983
15984 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15985 PyObject *resultobj = 0;
15986 wxImage *arg1 = (wxImage *) 0 ;
15987 bool arg2 = (bool) true ;
15988 void *argp1 = 0 ;
15989 int res1 = 0 ;
15990 bool val2 ;
15991 int ecode2 = 0 ;
15992 PyObject * obj0 = 0 ;
15993 PyObject * obj1 = 0 ;
15994 char * kwnames[] = {
15995 (char *) "self",(char *) "mask", NULL
15996 };
15997
15998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16002 }
16003 arg1 = reinterpret_cast< wxImage * >(argp1);
16004 if (obj1) {
16005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16006 if (!SWIG_IsOK(ecode2)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16008 }
16009 arg2 = static_cast< bool >(val2);
16010 }
16011 {
16012 PyThreadState* __tstate = wxPyBeginAllowThreads();
16013 (arg1)->SetMask(arg2);
16014 wxPyEndAllowThreads(__tstate);
16015 if (PyErr_Occurred()) SWIG_fail;
16016 }
16017 resultobj = SWIG_Py_Void();
16018 return resultobj;
16019 fail:
16020 return NULL;
16021 }
16022
16023
16024 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16025 PyObject *resultobj = 0;
16026 wxImage *arg1 = (wxImage *) 0 ;
16027 bool result;
16028 void *argp1 = 0 ;
16029 int res1 = 0 ;
16030 PyObject *swig_obj[1] ;
16031
16032 if (!args) SWIG_fail;
16033 swig_obj[0] = args;
16034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16035 if (!SWIG_IsOK(res1)) {
16036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16037 }
16038 arg1 = reinterpret_cast< wxImage * >(argp1);
16039 {
16040 PyThreadState* __tstate = wxPyBeginAllowThreads();
16041 result = (bool)(arg1)->HasMask();
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 {
16046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16047 }
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj = 0;
16056 wxImage *arg1 = (wxImage *) 0 ;
16057 double arg2 ;
16058 wxPoint *arg3 = 0 ;
16059 bool arg4 = (bool) true ;
16060 wxPoint *arg5 = (wxPoint *) NULL ;
16061 SwigValueWrapper<wxImage > result;
16062 void *argp1 = 0 ;
16063 int res1 = 0 ;
16064 double val2 ;
16065 int ecode2 = 0 ;
16066 wxPoint temp3 ;
16067 bool val4 ;
16068 int ecode4 = 0 ;
16069 void *argp5 = 0 ;
16070 int res5 = 0 ;
16071 PyObject * obj0 = 0 ;
16072 PyObject * obj1 = 0 ;
16073 PyObject * obj2 = 0 ;
16074 PyObject * obj3 = 0 ;
16075 PyObject * obj4 = 0 ;
16076 char * kwnames[] = {
16077 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16078 };
16079
16080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16082 if (!SWIG_IsOK(res1)) {
16083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16084 }
16085 arg1 = reinterpret_cast< wxImage * >(argp1);
16086 ecode2 = SWIG_AsVal_double(obj1, &val2);
16087 if (!SWIG_IsOK(ecode2)) {
16088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16089 }
16090 arg2 = static_cast< double >(val2);
16091 {
16092 arg3 = &temp3;
16093 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16094 }
16095 if (obj3) {
16096 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16097 if (!SWIG_IsOK(ecode4)) {
16098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16099 }
16100 arg4 = static_cast< bool >(val4);
16101 }
16102 if (obj4) {
16103 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16104 if (!SWIG_IsOK(res5)) {
16105 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16106 }
16107 arg5 = reinterpret_cast< wxPoint * >(argp5);
16108 }
16109 {
16110 PyThreadState* __tstate = wxPyBeginAllowThreads();
16111 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16112 wxPyEndAllowThreads(__tstate);
16113 if (PyErr_Occurred()) SWIG_fail;
16114 }
16115 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16116 return resultobj;
16117 fail:
16118 return NULL;
16119 }
16120
16121
16122 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16123 PyObject *resultobj = 0;
16124 wxImage *arg1 = (wxImage *) 0 ;
16125 bool arg2 = (bool) true ;
16126 SwigValueWrapper<wxImage > result;
16127 void *argp1 = 0 ;
16128 int res1 = 0 ;
16129 bool val2 ;
16130 int ecode2 = 0 ;
16131 PyObject * obj0 = 0 ;
16132 PyObject * obj1 = 0 ;
16133 char * kwnames[] = {
16134 (char *) "self",(char *) "clockwise", NULL
16135 };
16136
16137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16139 if (!SWIG_IsOK(res1)) {
16140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16141 }
16142 arg1 = reinterpret_cast< wxImage * >(argp1);
16143 if (obj1) {
16144 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16145 if (!SWIG_IsOK(ecode2)) {
16146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16147 }
16148 arg2 = static_cast< bool >(val2);
16149 }
16150 {
16151 PyThreadState* __tstate = wxPyBeginAllowThreads();
16152 result = (arg1)->Rotate90(arg2);
16153 wxPyEndAllowThreads(__tstate);
16154 if (PyErr_Occurred()) SWIG_fail;
16155 }
16156 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16157 return resultobj;
16158 fail:
16159 return NULL;
16160 }
16161
16162
16163 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16164 PyObject *resultobj = 0;
16165 wxImage *arg1 = (wxImage *) 0 ;
16166 bool arg2 = (bool) true ;
16167 SwigValueWrapper<wxImage > result;
16168 void *argp1 = 0 ;
16169 int res1 = 0 ;
16170 bool val2 ;
16171 int ecode2 = 0 ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *) "horizontally", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16182 }
16183 arg1 = reinterpret_cast< wxImage * >(argp1);
16184 if (obj1) {
16185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16186 if (!SWIG_IsOK(ecode2)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16188 }
16189 arg2 = static_cast< bool >(val2);
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = (arg1)->Mirror(arg2);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = 0;
16206 wxImage *arg1 = (wxImage *) 0 ;
16207 byte arg2 ;
16208 byte arg3 ;
16209 byte arg4 ;
16210 byte arg5 ;
16211 byte arg6 ;
16212 byte arg7 ;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 unsigned char val2 ;
16216 int ecode2 = 0 ;
16217 unsigned char val3 ;
16218 int ecode3 = 0 ;
16219 unsigned char val4 ;
16220 int ecode4 = 0 ;
16221 unsigned char val5 ;
16222 int ecode5 = 0 ;
16223 unsigned char val6 ;
16224 int ecode6 = 0 ;
16225 unsigned char val7 ;
16226 int ecode7 = 0 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 PyObject * obj2 = 0 ;
16230 PyObject * obj3 = 0 ;
16231 PyObject * obj4 = 0 ;
16232 PyObject * obj5 = 0 ;
16233 PyObject * obj6 = 0 ;
16234 char * kwnames[] = {
16235 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16236 };
16237
16238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16242 }
16243 arg1 = reinterpret_cast< wxImage * >(argp1);
16244 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16245 if (!SWIG_IsOK(ecode2)) {
16246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16247 }
16248 arg2 = static_cast< byte >(val2);
16249 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16250 if (!SWIG_IsOK(ecode3)) {
16251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16252 }
16253 arg3 = static_cast< byte >(val3);
16254 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16255 if (!SWIG_IsOK(ecode4)) {
16256 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16257 }
16258 arg4 = static_cast< byte >(val4);
16259 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16260 if (!SWIG_IsOK(ecode5)) {
16261 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16262 }
16263 arg5 = static_cast< byte >(val5);
16264 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16265 if (!SWIG_IsOK(ecode6)) {
16266 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16267 }
16268 arg6 = static_cast< byte >(val6);
16269 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16270 if (!SWIG_IsOK(ecode7)) {
16271 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16272 }
16273 arg7 = static_cast< byte >(val7);
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 resultobj = SWIG_Py_Void();
16281 return resultobj;
16282 fail:
16283 return NULL;
16284 }
16285
16286
16287 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16288 PyObject *resultobj = 0;
16289 wxImage *arg1 = (wxImage *) 0 ;
16290 double arg2 = (double) 0.299 ;
16291 double arg3 = (double) 0.587 ;
16292 double arg4 = (double) 0.114 ;
16293 SwigValueWrapper<wxImage > result;
16294 void *argp1 = 0 ;
16295 int res1 = 0 ;
16296 double val2 ;
16297 int ecode2 = 0 ;
16298 double val3 ;
16299 int ecode3 = 0 ;
16300 double val4 ;
16301 int ecode4 = 0 ;
16302 PyObject * obj0 = 0 ;
16303 PyObject * obj1 = 0 ;
16304 PyObject * obj2 = 0 ;
16305 PyObject * obj3 = 0 ;
16306 char * kwnames[] = {
16307 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16308 };
16309
16310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16312 if (!SWIG_IsOK(res1)) {
16313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16314 }
16315 arg1 = reinterpret_cast< wxImage * >(argp1);
16316 if (obj1) {
16317 ecode2 = SWIG_AsVal_double(obj1, &val2);
16318 if (!SWIG_IsOK(ecode2)) {
16319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16320 }
16321 arg2 = static_cast< double >(val2);
16322 }
16323 if (obj2) {
16324 ecode3 = SWIG_AsVal_double(obj2, &val3);
16325 if (!SWIG_IsOK(ecode3)) {
16326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16327 }
16328 arg3 = static_cast< double >(val3);
16329 }
16330 if (obj3) {
16331 ecode4 = SWIG_AsVal_double(obj3, &val4);
16332 if (!SWIG_IsOK(ecode4)) {
16333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16334 }
16335 arg4 = static_cast< double >(val4);
16336 }
16337 {
16338 PyThreadState* __tstate = wxPyBeginAllowThreads();
16339 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16340 wxPyEndAllowThreads(__tstate);
16341 if (PyErr_Occurred()) SWIG_fail;
16342 }
16343 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16344 return resultobj;
16345 fail:
16346 return NULL;
16347 }
16348
16349
16350 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16351 PyObject *resultobj = 0;
16352 wxImage *arg1 = (wxImage *) 0 ;
16353 byte arg2 ;
16354 byte arg3 ;
16355 byte arg4 ;
16356 SwigValueWrapper<wxImage > result;
16357 void *argp1 = 0 ;
16358 int res1 = 0 ;
16359 unsigned char val2 ;
16360 int ecode2 = 0 ;
16361 unsigned char val3 ;
16362 int ecode3 = 0 ;
16363 unsigned char val4 ;
16364 int ecode4 = 0 ;
16365 PyObject * obj0 = 0 ;
16366 PyObject * obj1 = 0 ;
16367 PyObject * obj2 = 0 ;
16368 PyObject * obj3 = 0 ;
16369 char * kwnames[] = {
16370 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16371 };
16372
16373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16375 if (!SWIG_IsOK(res1)) {
16376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16377 }
16378 arg1 = reinterpret_cast< wxImage * >(argp1);
16379 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16380 if (!SWIG_IsOK(ecode2)) {
16381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16382 }
16383 arg2 = static_cast< byte >(val2);
16384 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16385 if (!SWIG_IsOK(ecode3)) {
16386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16387 }
16388 arg3 = static_cast< byte >(val3);
16389 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16390 if (!SWIG_IsOK(ecode4)) {
16391 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16392 }
16393 arg4 = static_cast< byte >(val4);
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj = 0;
16409 wxImage *arg1 = (wxImage *) 0 ;
16410 wxString *arg2 = 0 ;
16411 wxString *arg3 = 0 ;
16412 void *argp1 = 0 ;
16413 int res1 = 0 ;
16414 bool temp2 = false ;
16415 bool temp3 = false ;
16416 PyObject * obj0 = 0 ;
16417 PyObject * obj1 = 0 ;
16418 PyObject * obj2 = 0 ;
16419 char * kwnames[] = {
16420 (char *) "self",(char *) "name",(char *) "value", NULL
16421 };
16422
16423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16425 if (!SWIG_IsOK(res1)) {
16426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16427 }
16428 arg1 = reinterpret_cast< wxImage * >(argp1);
16429 {
16430 arg2 = wxString_in_helper(obj1);
16431 if (arg2 == NULL) SWIG_fail;
16432 temp2 = true;
16433 }
16434 {
16435 arg3 = wxString_in_helper(obj2);
16436 if (arg3 == NULL) SWIG_fail;
16437 temp3 = true;
16438 }
16439 {
16440 PyThreadState* __tstate = wxPyBeginAllowThreads();
16441 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16442 wxPyEndAllowThreads(__tstate);
16443 if (PyErr_Occurred()) SWIG_fail;
16444 }
16445 resultobj = SWIG_Py_Void();
16446 {
16447 if (temp2)
16448 delete arg2;
16449 }
16450 {
16451 if (temp3)
16452 delete arg3;
16453 }
16454 return resultobj;
16455 fail:
16456 {
16457 if (temp2)
16458 delete arg2;
16459 }
16460 {
16461 if (temp3)
16462 delete arg3;
16463 }
16464 return NULL;
16465 }
16466
16467
16468 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16469 PyObject *resultobj = 0;
16470 wxImage *arg1 = (wxImage *) 0 ;
16471 wxString *arg2 = 0 ;
16472 int arg3 ;
16473 void *argp1 = 0 ;
16474 int res1 = 0 ;
16475 bool temp2 = false ;
16476 int val3 ;
16477 int ecode3 = 0 ;
16478 PyObject * obj0 = 0 ;
16479 PyObject * obj1 = 0 ;
16480 PyObject * obj2 = 0 ;
16481 char * kwnames[] = {
16482 (char *) "self",(char *) "name",(char *) "value", NULL
16483 };
16484
16485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16487 if (!SWIG_IsOK(res1)) {
16488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16489 }
16490 arg1 = reinterpret_cast< wxImage * >(argp1);
16491 {
16492 arg2 = wxString_in_helper(obj1);
16493 if (arg2 == NULL) SWIG_fail;
16494 temp2 = true;
16495 }
16496 ecode3 = SWIG_AsVal_int(obj2, &val3);
16497 if (!SWIG_IsOK(ecode3)) {
16498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16499 }
16500 arg3 = static_cast< int >(val3);
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 (arg1)->SetOption((wxString const &)*arg2,arg3);
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_Py_Void();
16508 {
16509 if (temp2)
16510 delete arg2;
16511 }
16512 return resultobj;
16513 fail:
16514 {
16515 if (temp2)
16516 delete arg2;
16517 }
16518 return NULL;
16519 }
16520
16521
16522 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16523 PyObject *resultobj = 0;
16524 wxImage *arg1 = (wxImage *) 0 ;
16525 wxString *arg2 = 0 ;
16526 wxString result;
16527 void *argp1 = 0 ;
16528 int res1 = 0 ;
16529 bool temp2 = false ;
16530 PyObject * obj0 = 0 ;
16531 PyObject * obj1 = 0 ;
16532 char * kwnames[] = {
16533 (char *) "self",(char *) "name", NULL
16534 };
16535
16536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16538 if (!SWIG_IsOK(res1)) {
16539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16540 }
16541 arg1 = reinterpret_cast< wxImage * >(argp1);
16542 {
16543 arg2 = wxString_in_helper(obj1);
16544 if (arg2 == NULL) SWIG_fail;
16545 temp2 = true;
16546 }
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16550 wxPyEndAllowThreads(__tstate);
16551 if (PyErr_Occurred()) SWIG_fail;
16552 }
16553 {
16554 #if wxUSE_UNICODE
16555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16556 #else
16557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16558 #endif
16559 }
16560 {
16561 if (temp2)
16562 delete arg2;
16563 }
16564 return resultobj;
16565 fail:
16566 {
16567 if (temp2)
16568 delete arg2;
16569 }
16570 return NULL;
16571 }
16572
16573
16574 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj = 0;
16576 wxImage *arg1 = (wxImage *) 0 ;
16577 wxString *arg2 = 0 ;
16578 int result;
16579 void *argp1 = 0 ;
16580 int res1 = 0 ;
16581 bool temp2 = false ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 char * kwnames[] = {
16585 (char *) "self",(char *) "name", NULL
16586 };
16587
16588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16590 if (!SWIG_IsOK(res1)) {
16591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16592 }
16593 arg1 = reinterpret_cast< wxImage * >(argp1);
16594 {
16595 arg2 = wxString_in_helper(obj1);
16596 if (arg2 == NULL) SWIG_fail;
16597 temp2 = true;
16598 }
16599 {
16600 PyThreadState* __tstate = wxPyBeginAllowThreads();
16601 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16602 wxPyEndAllowThreads(__tstate);
16603 if (PyErr_Occurred()) SWIG_fail;
16604 }
16605 resultobj = SWIG_From_int(static_cast< int >(result));
16606 {
16607 if (temp2)
16608 delete arg2;
16609 }
16610 return resultobj;
16611 fail:
16612 {
16613 if (temp2)
16614 delete arg2;
16615 }
16616 return NULL;
16617 }
16618
16619
16620 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16621 PyObject *resultobj = 0;
16622 wxImage *arg1 = (wxImage *) 0 ;
16623 wxString *arg2 = 0 ;
16624 bool result;
16625 void *argp1 = 0 ;
16626 int res1 = 0 ;
16627 bool temp2 = false ;
16628 PyObject * obj0 = 0 ;
16629 PyObject * obj1 = 0 ;
16630 char * kwnames[] = {
16631 (char *) "self",(char *) "name", NULL
16632 };
16633
16634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16636 if (!SWIG_IsOK(res1)) {
16637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16638 }
16639 arg1 = reinterpret_cast< wxImage * >(argp1);
16640 {
16641 arg2 = wxString_in_helper(obj1);
16642 if (arg2 == NULL) SWIG_fail;
16643 temp2 = true;
16644 }
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 {
16652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16653 }
16654 {
16655 if (temp2)
16656 delete arg2;
16657 }
16658 return resultobj;
16659 fail:
16660 {
16661 if (temp2)
16662 delete arg2;
16663 }
16664 return NULL;
16665 }
16666
16667
16668 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj = 0;
16670 wxImage *arg1 = (wxImage *) 0 ;
16671 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16672 unsigned long result;
16673 void *argp1 = 0 ;
16674 int res1 = 0 ;
16675 unsigned long val2 ;
16676 int ecode2 = 0 ;
16677 PyObject * obj0 = 0 ;
16678 PyObject * obj1 = 0 ;
16679 char * kwnames[] = {
16680 (char *) "self",(char *) "stopafter", NULL
16681 };
16682
16683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16685 if (!SWIG_IsOK(res1)) {
16686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16687 }
16688 arg1 = reinterpret_cast< wxImage * >(argp1);
16689 if (obj1) {
16690 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16691 if (!SWIG_IsOK(ecode2)) {
16692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16693 }
16694 arg2 = static_cast< unsigned long >(val2);
16695 }
16696 {
16697 PyThreadState* __tstate = wxPyBeginAllowThreads();
16698 result = (unsigned long)(arg1)->CountColours(arg2);
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16710 PyObject *resultobj = 0;
16711 wxImage *arg1 = (wxImage *) 0 ;
16712 wxImageHistogram *arg2 = 0 ;
16713 unsigned long result;
16714 void *argp1 = 0 ;
16715 int res1 = 0 ;
16716 void *argp2 = 0 ;
16717 int res2 = 0 ;
16718 PyObject * obj0 = 0 ;
16719 PyObject * obj1 = 0 ;
16720 char * kwnames[] = {
16721 (char *) "self",(char *) "h", NULL
16722 };
16723
16724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16726 if (!SWIG_IsOK(res1)) {
16727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16728 }
16729 arg1 = reinterpret_cast< wxImage * >(argp1);
16730 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16731 if (!SWIG_IsOK(res2)) {
16732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16733 }
16734 if (!argp2) {
16735 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16736 }
16737 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16741 wxPyEndAllowThreads(__tstate);
16742 if (PyErr_Occurred()) SWIG_fail;
16743 }
16744 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16745 return resultobj;
16746 fail:
16747 return NULL;
16748 }
16749
16750
16751 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16752 PyObject *resultobj = 0;
16753 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16754 void *argp1 = 0 ;
16755 int res1 = 0 ;
16756 PyObject * obj0 = 0 ;
16757 char * kwnames[] = {
16758 (char *) "handler", NULL
16759 };
16760
16761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16763 if (!SWIG_IsOK(res1)) {
16764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16765 }
16766 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 wxImage::AddHandler(arg1);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_Py_Void();
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16783 void *argp1 = 0 ;
16784 int res1 = 0 ;
16785 PyObject * obj0 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "handler", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16792 if (!SWIG_IsOK(res1)) {
16793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16794 }
16795 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16796 {
16797 PyThreadState* __tstate = wxPyBeginAllowThreads();
16798 wxImage::InsertHandler(arg1);
16799 wxPyEndAllowThreads(__tstate);
16800 if (PyErr_Occurred()) SWIG_fail;
16801 }
16802 resultobj = SWIG_Py_Void();
16803 return resultobj;
16804 fail:
16805 return NULL;
16806 }
16807
16808
16809 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16810 PyObject *resultobj = 0;
16811 wxString *arg1 = 0 ;
16812 bool result;
16813 bool temp1 = false ;
16814 PyObject * obj0 = 0 ;
16815 char * kwnames[] = {
16816 (char *) "name", NULL
16817 };
16818
16819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16820 {
16821 arg1 = wxString_in_helper(obj0);
16822 if (arg1 == NULL) SWIG_fail;
16823 temp1 = true;
16824 }
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 {
16832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16833 }
16834 {
16835 if (temp1)
16836 delete arg1;
16837 }
16838 return resultobj;
16839 fail:
16840 {
16841 if (temp1)
16842 delete arg1;
16843 }
16844 return NULL;
16845 }
16846
16847
16848 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16849 PyObject *resultobj = 0;
16850 PyObject *result = 0 ;
16851
16852 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16853 {
16854 PyThreadState* __tstate = wxPyBeginAllowThreads();
16855 result = (PyObject *)wxImage_GetHandlers();
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 resultobj = result;
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16867 PyObject *resultobj = 0;
16868 wxString result;
16869
16870 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = wxImage::GetImageExtWildcard();
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 {
16878 #if wxUSE_UNICODE
16879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16880 #else
16881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16882 #endif
16883 }
16884 return resultobj;
16885 fail:
16886 return NULL;
16887 }
16888
16889
16890 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16891 PyObject *resultobj = 0;
16892 wxImage *arg1 = (wxImage *) 0 ;
16893 int arg2 = (int) -1 ;
16894 wxBitmap result;
16895 void *argp1 = 0 ;
16896 int res1 = 0 ;
16897 int val2 ;
16898 int ecode2 = 0 ;
16899 PyObject * obj0 = 0 ;
16900 PyObject * obj1 = 0 ;
16901 char * kwnames[] = {
16902 (char *) "self",(char *) "depth", NULL
16903 };
16904
16905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16907 if (!SWIG_IsOK(res1)) {
16908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16909 }
16910 arg1 = reinterpret_cast< wxImage * >(argp1);
16911 if (obj1) {
16912 ecode2 = SWIG_AsVal_int(obj1, &val2);
16913 if (!SWIG_IsOK(ecode2)) {
16914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16915 }
16916 arg2 = static_cast< int >(val2);
16917 }
16918 {
16919 if (!wxPyCheckForApp()) SWIG_fail;
16920 PyThreadState* __tstate = wxPyBeginAllowThreads();
16921 result = wxImage_ConvertToBitmap(arg1,arg2);
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj = 0;
16934 wxImage *arg1 = (wxImage *) 0 ;
16935 byte arg2 ;
16936 byte arg3 ;
16937 byte arg4 ;
16938 wxBitmap result;
16939 void *argp1 = 0 ;
16940 int res1 = 0 ;
16941 unsigned char val2 ;
16942 int ecode2 = 0 ;
16943 unsigned char val3 ;
16944 int ecode3 = 0 ;
16945 unsigned char val4 ;
16946 int ecode4 = 0 ;
16947 PyObject * obj0 = 0 ;
16948 PyObject * obj1 = 0 ;
16949 PyObject * obj2 = 0 ;
16950 PyObject * obj3 = 0 ;
16951 char * kwnames[] = {
16952 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16953 };
16954
16955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16957 if (!SWIG_IsOK(res1)) {
16958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16959 }
16960 arg1 = reinterpret_cast< wxImage * >(argp1);
16961 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16962 if (!SWIG_IsOK(ecode2)) {
16963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16964 }
16965 arg2 = static_cast< byte >(val2);
16966 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16967 if (!SWIG_IsOK(ecode3)) {
16968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16969 }
16970 arg3 = static_cast< byte >(val3);
16971 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16972 if (!SWIG_IsOK(ecode4)) {
16973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16974 }
16975 arg4 = static_cast< byte >(val4);
16976 {
16977 if (!wxPyCheckForApp()) SWIG_fail;
16978 PyThreadState* __tstate = wxPyBeginAllowThreads();
16979 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16980 wxPyEndAllowThreads(__tstate);
16981 if (PyErr_Occurred()) SWIG_fail;
16982 }
16983 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16991 PyObject *resultobj = 0;
16992 wxImage *arg1 = (wxImage *) 0 ;
16993 double arg2 ;
16994 void *argp1 = 0 ;
16995 int res1 = 0 ;
16996 double val2 ;
16997 int ecode2 = 0 ;
16998 PyObject * obj0 = 0 ;
16999 PyObject * obj1 = 0 ;
17000 char * kwnames[] = {
17001 (char *) "self",(char *) "angle", NULL
17002 };
17003
17004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17006 if (!SWIG_IsOK(res1)) {
17007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17008 }
17009 arg1 = reinterpret_cast< wxImage * >(argp1);
17010 ecode2 = SWIG_AsVal_double(obj1, &val2);
17011 if (!SWIG_IsOK(ecode2)) {
17012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17013 }
17014 arg2 = static_cast< double >(val2);
17015 {
17016 PyThreadState* __tstate = wxPyBeginAllowThreads();
17017 (arg1)->RotateHue(arg2);
17018 wxPyEndAllowThreads(__tstate);
17019 if (PyErr_Occurred()) SWIG_fail;
17020 }
17021 resultobj = SWIG_Py_Void();
17022 return resultobj;
17023 fail:
17024 return NULL;
17025 }
17026
17027
17028 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj = 0;
17030 wxImage_RGBValue arg1 ;
17031 wxImage_HSVValue result;
17032 void *argp1 ;
17033 int res1 = 0 ;
17034 PyObject * obj0 = 0 ;
17035 char * kwnames[] = {
17036 (char *) "rgb", NULL
17037 };
17038
17039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17040 {
17041 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17042 if (!SWIG_IsOK(res1)) {
17043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17044 }
17045 if (!argp1) {
17046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17047 } else {
17048 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17049 arg1 = *temp;
17050 if (SWIG_IsNewObj(res1)) delete temp;
17051 }
17052 }
17053 {
17054 PyThreadState* __tstate = wxPyBeginAllowThreads();
17055 result = wxImage::RGBtoHSV(arg1);
17056 wxPyEndAllowThreads(__tstate);
17057 if (PyErr_Occurred()) SWIG_fail;
17058 }
17059 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17060 return resultobj;
17061 fail:
17062 return NULL;
17063 }
17064
17065
17066 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17067 PyObject *resultobj = 0;
17068 wxImage_HSVValue arg1 ;
17069 wxImage_RGBValue result;
17070 void *argp1 ;
17071 int res1 = 0 ;
17072 PyObject * obj0 = 0 ;
17073 char * kwnames[] = {
17074 (char *) "hsv", NULL
17075 };
17076
17077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17078 {
17079 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17080 if (!SWIG_IsOK(res1)) {
17081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17082 }
17083 if (!argp1) {
17084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17085 } else {
17086 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17087 arg1 = *temp;
17088 if (SWIG_IsNewObj(res1)) delete temp;
17089 }
17090 }
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 result = wxImage::HSVtoRGB(arg1);
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17098 return resultobj;
17099 fail:
17100 return NULL;
17101 }
17102
17103
17104 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17105 PyObject *obj;
17106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17107 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17108 return SWIG_Py_Void();
17109 }
17110
17111 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17112 return SWIG_Python_InitShadowInstance(args);
17113 }
17114
17115 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17116 PyObject *resultobj = 0;
17117 int arg1 ;
17118 int arg2 ;
17119 buffer arg3 ;
17120 int arg4 ;
17121 buffer arg5 = (buffer) NULL ;
17122 int arg6 = (int) 0 ;
17123 wxImage *result = 0 ;
17124 int val1 ;
17125 int ecode1 = 0 ;
17126 int val2 ;
17127 int ecode2 = 0 ;
17128 Py_ssize_t temp3 ;
17129 Py_ssize_t temp5 ;
17130 PyObject * obj0 = 0 ;
17131 PyObject * obj1 = 0 ;
17132 PyObject * obj2 = 0 ;
17133 PyObject * obj3 = 0 ;
17134 char * kwnames[] = {
17135 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17136 };
17137
17138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17139 ecode1 = SWIG_AsVal_int(obj0, &val1);
17140 if (!SWIG_IsOK(ecode1)) {
17141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17142 }
17143 arg1 = static_cast< int >(val1);
17144 ecode2 = SWIG_AsVal_int(obj1, &val2);
17145 if (!SWIG_IsOK(ecode2)) {
17146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17147 }
17148 arg2 = static_cast< int >(val2);
17149 {
17150 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17151 arg4 = (int)temp3;
17152 }
17153 if (obj3) {
17154 {
17155 if (obj3 != Py_None) {
17156 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17157 arg6 = (int)temp5;
17158 }
17159 }
17160 }
17161 {
17162 PyThreadState* __tstate = wxPyBeginAllowThreads();
17163 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17164 wxPyEndAllowThreads(__tstate);
17165 if (PyErr_Occurred()) SWIG_fail;
17166 }
17167 {
17168 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17169 }
17170 return resultobj;
17171 fail:
17172 return NULL;
17173 }
17174
17175
17176 SWIGINTERN int NullImage_set(PyObject *) {
17177 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17178 return 1;
17179 }
17180
17181
17182 SWIGINTERN PyObject *NullImage_get(void) {
17183 PyObject *pyobj = 0;
17184
17185 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17186 return pyobj;
17187 }
17188
17189
17190 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17191 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17192 return 1;
17193 }
17194
17195
17196 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17197 PyObject *pyobj = 0;
17198
17199 {
17200 #if wxUSE_UNICODE
17201 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17202 #else
17203 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17204 #endif
17205 }
17206 return pyobj;
17207 }
17208
17209
17210 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17211 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17212 return 1;
17213 }
17214
17215
17216 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17217 PyObject *pyobj = 0;
17218
17219 {
17220 #if wxUSE_UNICODE
17221 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17222 #else
17223 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17224 #endif
17225 }
17226 return pyobj;
17227 }
17228
17229
17230 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17231 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17232 return 1;
17233 }
17234
17235
17236 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17237 PyObject *pyobj = 0;
17238
17239 {
17240 #if wxUSE_UNICODE
17241 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17242 #else
17243 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17244 #endif
17245 }
17246 return pyobj;
17247 }
17248
17249
17250 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17251 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17252 return 1;
17253 }
17254
17255
17256 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17257 PyObject *pyobj = 0;
17258
17259 {
17260 #if wxUSE_UNICODE
17261 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17262 #else
17263 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17264 #endif
17265 }
17266 return pyobj;
17267 }
17268
17269
17270 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17271 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17272 return 1;
17273 }
17274
17275
17276 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17277 PyObject *pyobj = 0;
17278
17279 {
17280 #if wxUSE_UNICODE
17281 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17282 #else
17283 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17284 #endif
17285 }
17286 return pyobj;
17287 }
17288
17289
17290 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17291 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17292 return 1;
17293 }
17294
17295
17296 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17297 PyObject *pyobj = 0;
17298
17299 {
17300 #if wxUSE_UNICODE
17301 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17302 #else
17303 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17304 #endif
17305 }
17306 return pyobj;
17307 }
17308
17309
17310 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17311 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17312 return 1;
17313 }
17314
17315
17316 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17317 PyObject *pyobj = 0;
17318
17319 {
17320 #if wxUSE_UNICODE
17321 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17322 #else
17323 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17324 #endif
17325 }
17326 return pyobj;
17327 }
17328
17329
17330 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17331 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17332 return 1;
17333 }
17334
17335
17336 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17337 PyObject *pyobj = 0;
17338
17339 {
17340 #if wxUSE_UNICODE
17341 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17342 #else
17343 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17344 #endif
17345 }
17346 return pyobj;
17347 }
17348
17349
17350 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17351 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17352 return 1;
17353 }
17354
17355
17356 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17357 PyObject *pyobj = 0;
17358
17359 {
17360 #if wxUSE_UNICODE
17361 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17362 #else
17363 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17364 #endif
17365 }
17366 return pyobj;
17367 }
17368
17369
17370 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17371 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17372 return 1;
17373 }
17374
17375
17376 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17377 PyObject *pyobj = 0;
17378
17379 {
17380 #if wxUSE_UNICODE
17381 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17382 #else
17383 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17384 #endif
17385 }
17386 return pyobj;
17387 }
17388
17389
17390 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17391 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17392 return 1;
17393 }
17394
17395
17396 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17397 PyObject *pyobj = 0;
17398
17399 {
17400 #if wxUSE_UNICODE
17401 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17402 #else
17403 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17404 #endif
17405 }
17406 return pyobj;
17407 }
17408
17409
17410 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17411 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17412 return 1;
17413 }
17414
17415
17416 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17417 PyObject *pyobj = 0;
17418
17419 {
17420 #if wxUSE_UNICODE
17421 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17422 #else
17423 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17424 #endif
17425 }
17426 return pyobj;
17427 }
17428
17429
17430 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17431 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17432 return 1;
17433 }
17434
17435
17436 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17437 PyObject *pyobj = 0;
17438
17439 {
17440 #if wxUSE_UNICODE
17441 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17442 #else
17443 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17444 #endif
17445 }
17446 return pyobj;
17447 }
17448
17449
17450 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17451 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17452 return 1;
17453 }
17454
17455
17456 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17457 PyObject *pyobj = 0;
17458
17459 {
17460 #if wxUSE_UNICODE
17461 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17462 #else
17463 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17464 #endif
17465 }
17466 return pyobj;
17467 }
17468
17469
17470 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17471 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17472 return 1;
17473 }
17474
17475
17476 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17477 PyObject *pyobj = 0;
17478
17479 {
17480 #if wxUSE_UNICODE
17481 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17482 #else
17483 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17484 #endif
17485 }
17486 return pyobj;
17487 }
17488
17489
17490 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491 PyObject *resultobj = 0;
17492 wxBMPHandler *result = 0 ;
17493
17494 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17495 {
17496 PyThreadState* __tstate = wxPyBeginAllowThreads();
17497 result = (wxBMPHandler *)new wxBMPHandler();
17498 wxPyEndAllowThreads(__tstate);
17499 if (PyErr_Occurred()) SWIG_fail;
17500 }
17501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17502 return resultobj;
17503 fail:
17504 return NULL;
17505 }
17506
17507
17508 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17509 PyObject *obj;
17510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17511 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17512 return SWIG_Py_Void();
17513 }
17514
17515 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17516 return SWIG_Python_InitShadowInstance(args);
17517 }
17518
17519 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17520 PyObject *resultobj = 0;
17521 wxICOHandler *result = 0 ;
17522
17523 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = (wxICOHandler *)new wxICOHandler();
17527 wxPyEndAllowThreads(__tstate);
17528 if (PyErr_Occurred()) SWIG_fail;
17529 }
17530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17538 PyObject *obj;
17539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17540 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17541 return SWIG_Py_Void();
17542 }
17543
17544 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17545 return SWIG_Python_InitShadowInstance(args);
17546 }
17547
17548 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17549 PyObject *resultobj = 0;
17550 wxCURHandler *result = 0 ;
17551
17552 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (wxCURHandler *)new wxCURHandler();
17556 wxPyEndAllowThreads(__tstate);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 }
17559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17560 return resultobj;
17561 fail:
17562 return NULL;
17563 }
17564
17565
17566 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17567 PyObject *obj;
17568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17569 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17570 return SWIG_Py_Void();
17571 }
17572
17573 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 return SWIG_Python_InitShadowInstance(args);
17575 }
17576
17577 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17578 PyObject *resultobj = 0;
17579 wxANIHandler *result = 0 ;
17580
17581 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 result = (wxANIHandler *)new wxANIHandler();
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17589 return resultobj;
17590 fail:
17591 return NULL;
17592 }
17593
17594
17595 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17596 PyObject *obj;
17597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17598 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17599 return SWIG_Py_Void();
17600 }
17601
17602 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17603 return SWIG_Python_InitShadowInstance(args);
17604 }
17605
17606 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17607 PyObject *resultobj = 0;
17608 wxPNGHandler *result = 0 ;
17609
17610 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (wxPNGHandler *)new wxPNGHandler();
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17618 return resultobj;
17619 fail:
17620 return NULL;
17621 }
17622
17623
17624 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17625 PyObject *obj;
17626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17627 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17628 return SWIG_Py_Void();
17629 }
17630
17631 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17632 return SWIG_Python_InitShadowInstance(args);
17633 }
17634
17635 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17636 PyObject *resultobj = 0;
17637 wxGIFHandler *result = 0 ;
17638
17639 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (wxGIFHandler *)new wxGIFHandler();
17643 wxPyEndAllowThreads(__tstate);
17644 if (PyErr_Occurred()) SWIG_fail;
17645 }
17646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17654 PyObject *obj;
17655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17656 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17657 return SWIG_Py_Void();
17658 }
17659
17660 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17661 return SWIG_Python_InitShadowInstance(args);
17662 }
17663
17664 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17665 PyObject *resultobj = 0;
17666 wxPCXHandler *result = 0 ;
17667
17668 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (wxPCXHandler *)new wxPCXHandler();
17672 wxPyEndAllowThreads(__tstate);
17673 if (PyErr_Occurred()) SWIG_fail;
17674 }
17675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17676 return resultobj;
17677 fail:
17678 return NULL;
17679 }
17680
17681
17682 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17683 PyObject *obj;
17684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17685 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17686 return SWIG_Py_Void();
17687 }
17688
17689 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 return SWIG_Python_InitShadowInstance(args);
17691 }
17692
17693 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17694 PyObject *resultobj = 0;
17695 wxJPEGHandler *result = 0 ;
17696
17697 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 result = (wxJPEGHandler *)new wxJPEGHandler();
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17705 return resultobj;
17706 fail:
17707 return NULL;
17708 }
17709
17710
17711 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17712 PyObject *obj;
17713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17714 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17715 return SWIG_Py_Void();
17716 }
17717
17718 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17719 return SWIG_Python_InitShadowInstance(args);
17720 }
17721
17722 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17723 PyObject *resultobj = 0;
17724 wxPNMHandler *result = 0 ;
17725
17726 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (wxPNMHandler *)new wxPNMHandler();
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17734 return resultobj;
17735 fail:
17736 return NULL;
17737 }
17738
17739
17740 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17741 PyObject *obj;
17742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17743 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17744 return SWIG_Py_Void();
17745 }
17746
17747 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17748 return SWIG_Python_InitShadowInstance(args);
17749 }
17750
17751 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17752 PyObject *resultobj = 0;
17753 wxXPMHandler *result = 0 ;
17754
17755 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17756 {
17757 PyThreadState* __tstate = wxPyBeginAllowThreads();
17758 result = (wxXPMHandler *)new wxXPMHandler();
17759 wxPyEndAllowThreads(__tstate);
17760 if (PyErr_Occurred()) SWIG_fail;
17761 }
17762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17770 PyObject *obj;
17771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17772 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17773 return SWIG_Py_Void();
17774 }
17775
17776 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17777 return SWIG_Python_InitShadowInstance(args);
17778 }
17779
17780 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17781 PyObject *resultobj = 0;
17782 wxTIFFHandler *result = 0 ;
17783
17784 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 result = (wxTIFFHandler *)new wxTIFFHandler();
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17799 PyObject *obj;
17800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17801 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17802 return SWIG_Py_Void();
17803 }
17804
17805 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17806 return SWIG_Python_InitShadowInstance(args);
17807 }
17808
17809 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj = 0;
17811 wxImage *arg1 = 0 ;
17812 wxImage *arg2 = 0 ;
17813 int arg3 = (int) 236 ;
17814 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17815 bool result;
17816 void *argp1 = 0 ;
17817 int res1 = 0 ;
17818 void *argp2 = 0 ;
17819 int res2 = 0 ;
17820 int val3 ;
17821 int ecode3 = 0 ;
17822 int val4 ;
17823 int ecode4 = 0 ;
17824 PyObject * obj0 = 0 ;
17825 PyObject * obj1 = 0 ;
17826 PyObject * obj2 = 0 ;
17827 PyObject * obj3 = 0 ;
17828 char * kwnames[] = {
17829 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17830 };
17831
17832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17833 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17834 if (!SWIG_IsOK(res1)) {
17835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17836 }
17837 if (!argp1) {
17838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17839 }
17840 arg1 = reinterpret_cast< wxImage * >(argp1);
17841 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17842 if (!SWIG_IsOK(res2)) {
17843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17844 }
17845 if (!argp2) {
17846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17847 }
17848 arg2 = reinterpret_cast< wxImage * >(argp2);
17849 if (obj2) {
17850 ecode3 = SWIG_AsVal_int(obj2, &val3);
17851 if (!SWIG_IsOK(ecode3)) {
17852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17853 }
17854 arg3 = static_cast< int >(val3);
17855 }
17856 if (obj3) {
17857 ecode4 = SWIG_AsVal_int(obj3, &val4);
17858 if (!SWIG_IsOK(ecode4)) {
17859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17860 }
17861 arg4 = static_cast< int >(val4);
17862 }
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 {
17870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17871 }
17872 return resultobj;
17873 fail:
17874 return NULL;
17875 }
17876
17877
17878 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17879 PyObject *obj;
17880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17881 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17882 return SWIG_Py_Void();
17883 }
17884
17885 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17886 PyObject *resultobj = 0;
17887 wxEvtHandler *result = 0 ;
17888
17889 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17890 {
17891 PyThreadState* __tstate = wxPyBeginAllowThreads();
17892 result = (wxEvtHandler *)new wxEvtHandler();
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17897 return resultobj;
17898 fail:
17899 return NULL;
17900 }
17901
17902
17903 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17904 PyObject *resultobj = 0;
17905 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17906 wxEvtHandler *result = 0 ;
17907 void *argp1 = 0 ;
17908 int res1 = 0 ;
17909 PyObject *swig_obj[1] ;
17910
17911 if (!args) SWIG_fail;
17912 swig_obj[0] = args;
17913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17914 if (!SWIG_IsOK(res1)) {
17915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17916 }
17917 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17918 {
17919 PyThreadState* __tstate = wxPyBeginAllowThreads();
17920 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 {
17925 resultobj = wxPyMake_wxObject(result, 0);
17926 }
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17934 PyObject *resultobj = 0;
17935 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17936 wxEvtHandler *result = 0 ;
17937 void *argp1 = 0 ;
17938 int res1 = 0 ;
17939 PyObject *swig_obj[1] ;
17940
17941 if (!args) SWIG_fail;
17942 swig_obj[0] = args;
17943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17944 if (!SWIG_IsOK(res1)) {
17945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17946 }
17947 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17948 {
17949 PyThreadState* __tstate = wxPyBeginAllowThreads();
17950 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 {
17955 resultobj = wxPyMake_wxObject(result, 0);
17956 }
17957 return resultobj;
17958 fail:
17959 return NULL;
17960 }
17961
17962
17963 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17964 PyObject *resultobj = 0;
17965 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17966 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17967 void *argp1 = 0 ;
17968 int res1 = 0 ;
17969 void *argp2 = 0 ;
17970 int res2 = 0 ;
17971 PyObject * obj0 = 0 ;
17972 PyObject * obj1 = 0 ;
17973 char * kwnames[] = {
17974 (char *) "self",(char *) "handler", NULL
17975 };
17976
17977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17979 if (!SWIG_IsOK(res1)) {
17980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17981 }
17982 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17984 if (!SWIG_IsOK(res2)) {
17985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17986 }
17987 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17988 {
17989 PyThreadState* __tstate = wxPyBeginAllowThreads();
17990 (arg1)->SetNextHandler(arg2);
17991 wxPyEndAllowThreads(__tstate);
17992 if (PyErr_Occurred()) SWIG_fail;
17993 }
17994 resultobj = SWIG_Py_Void();
17995 return resultobj;
17996 fail:
17997 return NULL;
17998 }
17999
18000
18001 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18002 PyObject *resultobj = 0;
18003 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18004 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18005 void *argp1 = 0 ;
18006 int res1 = 0 ;
18007 void *argp2 = 0 ;
18008 int res2 = 0 ;
18009 PyObject * obj0 = 0 ;
18010 PyObject * obj1 = 0 ;
18011 char * kwnames[] = {
18012 (char *) "self",(char *) "handler", NULL
18013 };
18014
18015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18017 if (!SWIG_IsOK(res1)) {
18018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18019 }
18020 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18021 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18022 if (!SWIG_IsOK(res2)) {
18023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18024 }
18025 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18026 {
18027 PyThreadState* __tstate = wxPyBeginAllowThreads();
18028 (arg1)->SetPreviousHandler(arg2);
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 resultobj = SWIG_Py_Void();
18033 return resultobj;
18034 fail:
18035 return NULL;
18036 }
18037
18038
18039 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18040 PyObject *resultobj = 0;
18041 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18042 bool result;
18043 void *argp1 = 0 ;
18044 int res1 = 0 ;
18045 PyObject *swig_obj[1] ;
18046
18047 if (!args) SWIG_fail;
18048 swig_obj[0] = args;
18049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18050 if (!SWIG_IsOK(res1)) {
18051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18052 }
18053 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18054 {
18055 PyThreadState* __tstate = wxPyBeginAllowThreads();
18056 result = (bool)(arg1)->GetEvtHandlerEnabled();
18057 wxPyEndAllowThreads(__tstate);
18058 if (PyErr_Occurred()) SWIG_fail;
18059 }
18060 {
18061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18062 }
18063 return resultobj;
18064 fail:
18065 return NULL;
18066 }
18067
18068
18069 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj = 0;
18071 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18072 bool arg2 ;
18073 void *argp1 = 0 ;
18074 int res1 = 0 ;
18075 bool val2 ;
18076 int ecode2 = 0 ;
18077 PyObject * obj0 = 0 ;
18078 PyObject * obj1 = 0 ;
18079 char * kwnames[] = {
18080 (char *) "self",(char *) "enabled", NULL
18081 };
18082
18083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18085 if (!SWIG_IsOK(res1)) {
18086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18087 }
18088 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18089 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18090 if (!SWIG_IsOK(ecode2)) {
18091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18092 }
18093 arg2 = static_cast< bool >(val2);
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 (arg1)->SetEvtHandlerEnabled(arg2);
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 resultobj = SWIG_Py_Void();
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18108 PyObject *resultobj = 0;
18109 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18110 wxEvent *arg2 = 0 ;
18111 bool result;
18112 void *argp1 = 0 ;
18113 int res1 = 0 ;
18114 void *argp2 = 0 ;
18115 int res2 = 0 ;
18116 PyObject * obj0 = 0 ;
18117 PyObject * obj1 = 0 ;
18118 char * kwnames[] = {
18119 (char *) "self",(char *) "event", NULL
18120 };
18121
18122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18124 if (!SWIG_IsOK(res1)) {
18125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18126 }
18127 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18129 if (!SWIG_IsOK(res2)) {
18130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18131 }
18132 if (!argp2) {
18133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18134 }
18135 arg2 = reinterpret_cast< wxEvent * >(argp2);
18136 {
18137 PyThreadState* __tstate = wxPyBeginAllowThreads();
18138 result = (bool)(arg1)->ProcessEvent(*arg2);
18139 wxPyEndAllowThreads(__tstate);
18140 if (PyErr_Occurred()) SWIG_fail;
18141 }
18142 {
18143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18144 }
18145 return resultobj;
18146 fail:
18147 return NULL;
18148 }
18149
18150
18151 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18152 PyObject *resultobj = 0;
18153 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18154 wxEvent *arg2 = 0 ;
18155 void *argp1 = 0 ;
18156 int res1 = 0 ;
18157 void *argp2 = 0 ;
18158 int res2 = 0 ;
18159 PyObject * obj0 = 0 ;
18160 PyObject * obj1 = 0 ;
18161 char * kwnames[] = {
18162 (char *) "self",(char *) "event", NULL
18163 };
18164
18165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18167 if (!SWIG_IsOK(res1)) {
18168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18169 }
18170 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18172 if (!SWIG_IsOK(res2)) {
18173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18174 }
18175 if (!argp2) {
18176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18177 }
18178 arg2 = reinterpret_cast< wxEvent * >(argp2);
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 (arg1)->AddPendingEvent(*arg2);
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 resultobj = SWIG_Py_Void();
18186 return resultobj;
18187 fail:
18188 return NULL;
18189 }
18190
18191
18192 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18193 PyObject *resultobj = 0;
18194 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 PyObject *swig_obj[1] ;
18198
18199 if (!args) SWIG_fail;
18200 swig_obj[0] = args;
18201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18202 if (!SWIG_IsOK(res1)) {
18203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18204 }
18205 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 (arg1)->ProcessPendingEvents();
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 resultobj = SWIG_Py_Void();
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18220 PyObject *resultobj = 0;
18221 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18222 int arg2 ;
18223 int arg3 ;
18224 int arg4 ;
18225 PyObject *arg5 = (PyObject *) 0 ;
18226 void *argp1 = 0 ;
18227 int res1 = 0 ;
18228 int val2 ;
18229 int ecode2 = 0 ;
18230 int val3 ;
18231 int ecode3 = 0 ;
18232 int val4 ;
18233 int ecode4 = 0 ;
18234 PyObject * obj0 = 0 ;
18235 PyObject * obj1 = 0 ;
18236 PyObject * obj2 = 0 ;
18237 PyObject * obj3 = 0 ;
18238 PyObject * obj4 = 0 ;
18239 char * kwnames[] = {
18240 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18241 };
18242
18243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18249 ecode2 = SWIG_AsVal_int(obj1, &val2);
18250 if (!SWIG_IsOK(ecode2)) {
18251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18252 }
18253 arg2 = static_cast< int >(val2);
18254 ecode3 = SWIG_AsVal_int(obj2, &val3);
18255 if (!SWIG_IsOK(ecode3)) {
18256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18257 }
18258 arg3 = static_cast< int >(val3);
18259 ecode4 = SWIG_AsVal_int(obj3, &val4);
18260 if (!SWIG_IsOK(ecode4)) {
18261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18262 }
18263 arg4 = static_cast< int >(val4);
18264 arg5 = obj4;
18265 {
18266 PyThreadState* __tstate = wxPyBeginAllowThreads();
18267 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18268 wxPyEndAllowThreads(__tstate);
18269 if (PyErr_Occurred()) SWIG_fail;
18270 }
18271 resultobj = SWIG_Py_Void();
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj = 0;
18280 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18281 int arg2 ;
18282 int arg3 = (int) -1 ;
18283 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18284 bool result;
18285 void *argp1 = 0 ;
18286 int res1 = 0 ;
18287 int val2 ;
18288 int ecode2 = 0 ;
18289 int val3 ;
18290 int ecode3 = 0 ;
18291 int val4 ;
18292 int ecode4 = 0 ;
18293 PyObject * obj0 = 0 ;
18294 PyObject * obj1 = 0 ;
18295 PyObject * obj2 = 0 ;
18296 PyObject * obj3 = 0 ;
18297 char * kwnames[] = {
18298 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18299 };
18300
18301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18305 }
18306 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18307 ecode2 = SWIG_AsVal_int(obj1, &val2);
18308 if (!SWIG_IsOK(ecode2)) {
18309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18310 }
18311 arg2 = static_cast< int >(val2);
18312 if (obj2) {
18313 ecode3 = SWIG_AsVal_int(obj2, &val3);
18314 if (!SWIG_IsOK(ecode3)) {
18315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18316 }
18317 arg3 = static_cast< int >(val3);
18318 }
18319 if (obj3) {
18320 ecode4 = SWIG_AsVal_int(obj3, &val4);
18321 if (!SWIG_IsOK(ecode4)) {
18322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18323 }
18324 arg4 = static_cast< wxEventType >(val4);
18325 }
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 {
18333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18334 }
18335 return resultobj;
18336 fail:
18337 return NULL;
18338 }
18339
18340
18341 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18342 PyObject *resultobj = 0;
18343 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18344 PyObject *arg2 = (PyObject *) 0 ;
18345 bool arg3 = (bool) true ;
18346 void *argp1 = 0 ;
18347 int res1 = 0 ;
18348 bool val3 ;
18349 int ecode3 = 0 ;
18350 PyObject * obj0 = 0 ;
18351 PyObject * obj1 = 0 ;
18352 PyObject * obj2 = 0 ;
18353 char * kwnames[] = {
18354 (char *) "self",(char *) "_self",(char *) "incref", NULL
18355 };
18356
18357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18359 if (!SWIG_IsOK(res1)) {
18360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18361 }
18362 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18363 arg2 = obj1;
18364 if (obj2) {
18365 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18366 if (!SWIG_IsOK(ecode3)) {
18367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18368 }
18369 arg3 = static_cast< bool >(val3);
18370 }
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 resultobj = SWIG_Py_Void();
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18385 PyObject *obj;
18386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18387 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18388 return SWIG_Py_Void();
18389 }
18390
18391 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18392 return SWIG_Python_InitShadowInstance(args);
18393 }
18394
18395 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18396 PyObject *resultobj = 0;
18397 wxEventType result;
18398
18399 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18400 {
18401 PyThreadState* __tstate = wxPyBeginAllowThreads();
18402 result = (wxEventType)wxNewEventType();
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 resultobj = SWIG_From_int(static_cast< int >(result));
18407 return resultobj;
18408 fail:
18409 return NULL;
18410 }
18411
18412
18413 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18414 PyObject *resultobj = 0;
18415 wxEvent *arg1 = (wxEvent *) 0 ;
18416 void *argp1 = 0 ;
18417 int res1 = 0 ;
18418 PyObject *swig_obj[1] ;
18419
18420 if (!args) SWIG_fail;
18421 swig_obj[0] = args;
18422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18423 if (!SWIG_IsOK(res1)) {
18424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18425 }
18426 arg1 = reinterpret_cast< wxEvent * >(argp1);
18427 {
18428 PyThreadState* __tstate = wxPyBeginAllowThreads();
18429 delete arg1;
18430
18431 wxPyEndAllowThreads(__tstate);
18432 if (PyErr_Occurred()) SWIG_fail;
18433 }
18434 resultobj = SWIG_Py_Void();
18435 return resultobj;
18436 fail:
18437 return NULL;
18438 }
18439
18440
18441 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj = 0;
18443 wxEvent *arg1 = (wxEvent *) 0 ;
18444 wxEventType arg2 ;
18445 void *argp1 = 0 ;
18446 int res1 = 0 ;
18447 int val2 ;
18448 int ecode2 = 0 ;
18449 PyObject * obj0 = 0 ;
18450 PyObject * obj1 = 0 ;
18451 char * kwnames[] = {
18452 (char *) "self",(char *) "typ", NULL
18453 };
18454
18455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18457 if (!SWIG_IsOK(res1)) {
18458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18459 }
18460 arg1 = reinterpret_cast< wxEvent * >(argp1);
18461 ecode2 = SWIG_AsVal_int(obj1, &val2);
18462 if (!SWIG_IsOK(ecode2)) {
18463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18464 }
18465 arg2 = static_cast< wxEventType >(val2);
18466 {
18467 PyThreadState* __tstate = wxPyBeginAllowThreads();
18468 (arg1)->SetEventType(arg2);
18469 wxPyEndAllowThreads(__tstate);
18470 if (PyErr_Occurred()) SWIG_fail;
18471 }
18472 resultobj = SWIG_Py_Void();
18473 return resultobj;
18474 fail:
18475 return NULL;
18476 }
18477
18478
18479 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18480 PyObject *resultobj = 0;
18481 wxEvent *arg1 = (wxEvent *) 0 ;
18482 wxEventType result;
18483 void *argp1 = 0 ;
18484 int res1 = 0 ;
18485 PyObject *swig_obj[1] ;
18486
18487 if (!args) SWIG_fail;
18488 swig_obj[0] = args;
18489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18490 if (!SWIG_IsOK(res1)) {
18491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18492 }
18493 arg1 = reinterpret_cast< wxEvent * >(argp1);
18494 {
18495 PyThreadState* __tstate = wxPyBeginAllowThreads();
18496 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18497 wxPyEndAllowThreads(__tstate);
18498 if (PyErr_Occurred()) SWIG_fail;
18499 }
18500 resultobj = SWIG_From_int(static_cast< int >(result));
18501 return resultobj;
18502 fail:
18503 return NULL;
18504 }
18505
18506
18507 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18508 PyObject *resultobj = 0;
18509 wxEvent *arg1 = (wxEvent *) 0 ;
18510 wxObject *result = 0 ;
18511 void *argp1 = 0 ;
18512 int res1 = 0 ;
18513 PyObject *swig_obj[1] ;
18514
18515 if (!args) SWIG_fail;
18516 swig_obj[0] = args;
18517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18518 if (!SWIG_IsOK(res1)) {
18519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18520 }
18521 arg1 = reinterpret_cast< wxEvent * >(argp1);
18522 {
18523 PyThreadState* __tstate = wxPyBeginAllowThreads();
18524 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18525 wxPyEndAllowThreads(__tstate);
18526 if (PyErr_Occurred()) SWIG_fail;
18527 }
18528 {
18529 resultobj = wxPyMake_wxObject(result, (bool)0);
18530 }
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18538 PyObject *resultobj = 0;
18539 wxEvent *arg1 = (wxEvent *) 0 ;
18540 wxObject *arg2 = (wxObject *) 0 ;
18541 void *argp1 = 0 ;
18542 int res1 = 0 ;
18543 void *argp2 = 0 ;
18544 int res2 = 0 ;
18545 PyObject * obj0 = 0 ;
18546 PyObject * obj1 = 0 ;
18547 char * kwnames[] = {
18548 (char *) "self",(char *) "obj", NULL
18549 };
18550
18551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18553 if (!SWIG_IsOK(res1)) {
18554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18555 }
18556 arg1 = reinterpret_cast< wxEvent * >(argp1);
18557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18558 if (!SWIG_IsOK(res2)) {
18559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18560 }
18561 arg2 = reinterpret_cast< wxObject * >(argp2);
18562 {
18563 PyThreadState* __tstate = wxPyBeginAllowThreads();
18564 (arg1)->SetEventObject(arg2);
18565 wxPyEndAllowThreads(__tstate);
18566 if (PyErr_Occurred()) SWIG_fail;
18567 }
18568 resultobj = SWIG_Py_Void();
18569 return resultobj;
18570 fail:
18571 return NULL;
18572 }
18573
18574
18575 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18576 PyObject *resultobj = 0;
18577 wxEvent *arg1 = (wxEvent *) 0 ;
18578 long result;
18579 void *argp1 = 0 ;
18580 int res1 = 0 ;
18581 PyObject *swig_obj[1] ;
18582
18583 if (!args) SWIG_fail;
18584 swig_obj[0] = args;
18585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18586 if (!SWIG_IsOK(res1)) {
18587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18588 }
18589 arg1 = reinterpret_cast< wxEvent * >(argp1);
18590 {
18591 PyThreadState* __tstate = wxPyBeginAllowThreads();
18592 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18593 wxPyEndAllowThreads(__tstate);
18594 if (PyErr_Occurred()) SWIG_fail;
18595 }
18596 resultobj = SWIG_From_long(static_cast< long >(result));
18597 return resultobj;
18598 fail:
18599 return NULL;
18600 }
18601
18602
18603 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18604 PyObject *resultobj = 0;
18605 wxEvent *arg1 = (wxEvent *) 0 ;
18606 long arg2 = (long) 0 ;
18607 void *argp1 = 0 ;
18608 int res1 = 0 ;
18609 long val2 ;
18610 int ecode2 = 0 ;
18611 PyObject * obj0 = 0 ;
18612 PyObject * obj1 = 0 ;
18613 char * kwnames[] = {
18614 (char *) "self",(char *) "ts", NULL
18615 };
18616
18617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18619 if (!SWIG_IsOK(res1)) {
18620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18621 }
18622 arg1 = reinterpret_cast< wxEvent * >(argp1);
18623 if (obj1) {
18624 ecode2 = SWIG_AsVal_long(obj1, &val2);
18625 if (!SWIG_IsOK(ecode2)) {
18626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18627 }
18628 arg2 = static_cast< long >(val2);
18629 }
18630 {
18631 PyThreadState* __tstate = wxPyBeginAllowThreads();
18632 (arg1)->SetTimestamp(arg2);
18633 wxPyEndAllowThreads(__tstate);
18634 if (PyErr_Occurred()) SWIG_fail;
18635 }
18636 resultobj = SWIG_Py_Void();
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxEvent *arg1 = (wxEvent *) 0 ;
18646 int result;
18647 void *argp1 = 0 ;
18648 int res1 = 0 ;
18649 PyObject *swig_obj[1] ;
18650
18651 if (!args) SWIG_fail;
18652 swig_obj[0] = args;
18653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18656 }
18657 arg1 = reinterpret_cast< wxEvent * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (int)((wxEvent const *)arg1)->GetId();
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 resultobj = SWIG_From_int(static_cast< int >(result));
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18672 PyObject *resultobj = 0;
18673 wxEvent *arg1 = (wxEvent *) 0 ;
18674 int arg2 ;
18675 void *argp1 = 0 ;
18676 int res1 = 0 ;
18677 int val2 ;
18678 int ecode2 = 0 ;
18679 PyObject * obj0 = 0 ;
18680 PyObject * obj1 = 0 ;
18681 char * kwnames[] = {
18682 (char *) "self",(char *) "Id", NULL
18683 };
18684
18685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18687 if (!SWIG_IsOK(res1)) {
18688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18689 }
18690 arg1 = reinterpret_cast< wxEvent * >(argp1);
18691 ecode2 = SWIG_AsVal_int(obj1, &val2);
18692 if (!SWIG_IsOK(ecode2)) {
18693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18694 }
18695 arg2 = static_cast< int >(val2);
18696 {
18697 PyThreadState* __tstate = wxPyBeginAllowThreads();
18698 (arg1)->SetId(arg2);
18699 wxPyEndAllowThreads(__tstate);
18700 if (PyErr_Occurred()) SWIG_fail;
18701 }
18702 resultobj = SWIG_Py_Void();
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18710 PyObject *resultobj = 0;
18711 wxEvent *arg1 = (wxEvent *) 0 ;
18712 bool result;
18713 void *argp1 = 0 ;
18714 int res1 = 0 ;
18715 PyObject *swig_obj[1] ;
18716
18717 if (!args) SWIG_fail;
18718 swig_obj[0] = args;
18719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18720 if (!SWIG_IsOK(res1)) {
18721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18722 }
18723 arg1 = reinterpret_cast< wxEvent * >(argp1);
18724 {
18725 PyThreadState* __tstate = wxPyBeginAllowThreads();
18726 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 {
18731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18732 }
18733 return resultobj;
18734 fail:
18735 return NULL;
18736 }
18737
18738
18739 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18740 PyObject *resultobj = 0;
18741 wxEvent *arg1 = (wxEvent *) 0 ;
18742 bool arg2 = (bool) true ;
18743 void *argp1 = 0 ;
18744 int res1 = 0 ;
18745 bool val2 ;
18746 int ecode2 = 0 ;
18747 PyObject * obj0 = 0 ;
18748 PyObject * obj1 = 0 ;
18749 char * kwnames[] = {
18750 (char *) "self",(char *) "skip", NULL
18751 };
18752
18753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18755 if (!SWIG_IsOK(res1)) {
18756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18757 }
18758 arg1 = reinterpret_cast< wxEvent * >(argp1);
18759 if (obj1) {
18760 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18761 if (!SWIG_IsOK(ecode2)) {
18762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18763 }
18764 arg2 = static_cast< bool >(val2);
18765 }
18766 {
18767 PyThreadState* __tstate = wxPyBeginAllowThreads();
18768 (arg1)->Skip(arg2);
18769 wxPyEndAllowThreads(__tstate);
18770 if (PyErr_Occurred()) SWIG_fail;
18771 }
18772 resultobj = SWIG_Py_Void();
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18780 PyObject *resultobj = 0;
18781 wxEvent *arg1 = (wxEvent *) 0 ;
18782 bool result;
18783 void *argp1 = 0 ;
18784 int res1 = 0 ;
18785 PyObject *swig_obj[1] ;
18786
18787 if (!args) SWIG_fail;
18788 swig_obj[0] = args;
18789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18790 if (!SWIG_IsOK(res1)) {
18791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18792 }
18793 arg1 = reinterpret_cast< wxEvent * >(argp1);
18794 {
18795 PyThreadState* __tstate = wxPyBeginAllowThreads();
18796 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18797 wxPyEndAllowThreads(__tstate);
18798 if (PyErr_Occurred()) SWIG_fail;
18799 }
18800 {
18801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18802 }
18803 return resultobj;
18804 fail:
18805 return NULL;
18806 }
18807
18808
18809 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18810 PyObject *resultobj = 0;
18811 wxEvent *arg1 = (wxEvent *) 0 ;
18812 bool result;
18813 void *argp1 = 0 ;
18814 int res1 = 0 ;
18815 PyObject *swig_obj[1] ;
18816
18817 if (!args) SWIG_fail;
18818 swig_obj[0] = args;
18819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18820 if (!SWIG_IsOK(res1)) {
18821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18822 }
18823 arg1 = reinterpret_cast< wxEvent * >(argp1);
18824 {
18825 PyThreadState* __tstate = wxPyBeginAllowThreads();
18826 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18827 wxPyEndAllowThreads(__tstate);
18828 if (PyErr_Occurred()) SWIG_fail;
18829 }
18830 {
18831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18832 }
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18840 PyObject *resultobj = 0;
18841 wxEvent *arg1 = (wxEvent *) 0 ;
18842 int result;
18843 void *argp1 = 0 ;
18844 int res1 = 0 ;
18845 PyObject *swig_obj[1] ;
18846
18847 if (!args) SWIG_fail;
18848 swig_obj[0] = args;
18849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18850 if (!SWIG_IsOK(res1)) {
18851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18852 }
18853 arg1 = reinterpret_cast< wxEvent * >(argp1);
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 result = (int)(arg1)->StopPropagation();
18857 wxPyEndAllowThreads(__tstate);
18858 if (PyErr_Occurred()) SWIG_fail;
18859 }
18860 resultobj = SWIG_From_int(static_cast< int >(result));
18861 return resultobj;
18862 fail:
18863 return NULL;
18864 }
18865
18866
18867 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18868 PyObject *resultobj = 0;
18869 wxEvent *arg1 = (wxEvent *) 0 ;
18870 int arg2 ;
18871 void *argp1 = 0 ;
18872 int res1 = 0 ;
18873 int val2 ;
18874 int ecode2 = 0 ;
18875 PyObject * obj0 = 0 ;
18876 PyObject * obj1 = 0 ;
18877 char * kwnames[] = {
18878 (char *) "self",(char *) "propagationLevel", NULL
18879 };
18880
18881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18883 if (!SWIG_IsOK(res1)) {
18884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18885 }
18886 arg1 = reinterpret_cast< wxEvent * >(argp1);
18887 ecode2 = SWIG_AsVal_int(obj1, &val2);
18888 if (!SWIG_IsOK(ecode2)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18890 }
18891 arg2 = static_cast< int >(val2);
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 (arg1)->ResumePropagation(arg2);
18895 wxPyEndAllowThreads(__tstate);
18896 if (PyErr_Occurred()) SWIG_fail;
18897 }
18898 resultobj = SWIG_Py_Void();
18899 return resultobj;
18900 fail:
18901 return NULL;
18902 }
18903
18904
18905 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18906 PyObject *resultobj = 0;
18907 wxEvent *arg1 = (wxEvent *) 0 ;
18908 wxEvent *result = 0 ;
18909 void *argp1 = 0 ;
18910 int res1 = 0 ;
18911 PyObject *swig_obj[1] ;
18912
18913 if (!args) SWIG_fail;
18914 swig_obj[0] = args;
18915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18916 if (!SWIG_IsOK(res1)) {
18917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18918 }
18919 arg1 = reinterpret_cast< wxEvent * >(argp1);
18920 {
18921 PyThreadState* __tstate = wxPyBeginAllowThreads();
18922 result = (wxEvent *)(arg1)->Clone();
18923 wxPyEndAllowThreads(__tstate);
18924 if (PyErr_Occurred()) SWIG_fail;
18925 }
18926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18927 return resultobj;
18928 fail:
18929 return NULL;
18930 }
18931
18932
18933 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18934 PyObject *obj;
18935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18936 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18937 return SWIG_Py_Void();
18938 }
18939
18940 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18941 PyObject *resultobj = 0;
18942 wxEvent *arg1 = 0 ;
18943 wxPropagationDisabler *result = 0 ;
18944 void *argp1 = 0 ;
18945 int res1 = 0 ;
18946 PyObject * obj0 = 0 ;
18947 char * kwnames[] = {
18948 (char *) "event", NULL
18949 };
18950
18951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18952 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18953 if (!SWIG_IsOK(res1)) {
18954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18955 }
18956 if (!argp1) {
18957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18958 }
18959 arg1 = reinterpret_cast< wxEvent * >(argp1);
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18974 PyObject *resultobj = 0;
18975 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18976 void *argp1 = 0 ;
18977 int res1 = 0 ;
18978 PyObject *swig_obj[1] ;
18979
18980 if (!args) SWIG_fail;
18981 swig_obj[0] = args;
18982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18983 if (!SWIG_IsOK(res1)) {
18984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18985 }
18986 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18987 {
18988 PyThreadState* __tstate = wxPyBeginAllowThreads();
18989 delete arg1;
18990
18991 wxPyEndAllowThreads(__tstate);
18992 if (PyErr_Occurred()) SWIG_fail;
18993 }
18994 resultobj = SWIG_Py_Void();
18995 return resultobj;
18996 fail:
18997 return NULL;
18998 }
18999
19000
19001 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19002 PyObject *obj;
19003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19004 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19005 return SWIG_Py_Void();
19006 }
19007
19008 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19009 return SWIG_Python_InitShadowInstance(args);
19010 }
19011
19012 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj = 0;
19014 wxEvent *arg1 = 0 ;
19015 wxPropagateOnce *result = 0 ;
19016 void *argp1 = 0 ;
19017 int res1 = 0 ;
19018 PyObject * obj0 = 0 ;
19019 char * kwnames[] = {
19020 (char *) "event", NULL
19021 };
19022
19023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19024 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19025 if (!SWIG_IsOK(res1)) {
19026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19027 }
19028 if (!argp1) {
19029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19030 }
19031 arg1 = reinterpret_cast< wxEvent * >(argp1);
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19046 PyObject *resultobj = 0;
19047 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19048 void *argp1 = 0 ;
19049 int res1 = 0 ;
19050 PyObject *swig_obj[1] ;
19051
19052 if (!args) SWIG_fail;
19053 swig_obj[0] = args;
19054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19055 if (!SWIG_IsOK(res1)) {
19056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19057 }
19058 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19059 {
19060 PyThreadState* __tstate = wxPyBeginAllowThreads();
19061 delete arg1;
19062
19063 wxPyEndAllowThreads(__tstate);
19064 if (PyErr_Occurred()) SWIG_fail;
19065 }
19066 resultobj = SWIG_Py_Void();
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19074 PyObject *obj;
19075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19076 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19077 return SWIG_Py_Void();
19078 }
19079
19080 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19081 return SWIG_Python_InitShadowInstance(args);
19082 }
19083
19084 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19085 PyObject *resultobj = 0;
19086 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19087 int arg2 = (int) 0 ;
19088 wxCommandEvent *result = 0 ;
19089 int val1 ;
19090 int ecode1 = 0 ;
19091 int val2 ;
19092 int ecode2 = 0 ;
19093 PyObject * obj0 = 0 ;
19094 PyObject * obj1 = 0 ;
19095 char * kwnames[] = {
19096 (char *) "commandType",(char *) "winid", NULL
19097 };
19098
19099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19100 if (obj0) {
19101 ecode1 = SWIG_AsVal_int(obj0, &val1);
19102 if (!SWIG_IsOK(ecode1)) {
19103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19104 }
19105 arg1 = static_cast< wxEventType >(val1);
19106 }
19107 if (obj1) {
19108 ecode2 = SWIG_AsVal_int(obj1, &val2);
19109 if (!SWIG_IsOK(ecode2)) {
19110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19111 }
19112 arg2 = static_cast< int >(val2);
19113 }
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19128 PyObject *resultobj = 0;
19129 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19130 int result;
19131 void *argp1 = 0 ;
19132 int res1 = 0 ;
19133 PyObject *swig_obj[1] ;
19134
19135 if (!args) SWIG_fail;
19136 swig_obj[0] = args;
19137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19138 if (!SWIG_IsOK(res1)) {
19139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19140 }
19141 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19145 wxPyEndAllowThreads(__tstate);
19146 if (PyErr_Occurred()) SWIG_fail;
19147 }
19148 resultobj = SWIG_From_int(static_cast< int >(result));
19149 return resultobj;
19150 fail:
19151 return NULL;
19152 }
19153
19154
19155 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19156 PyObject *resultobj = 0;
19157 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19158 wxString *arg2 = 0 ;
19159 void *argp1 = 0 ;
19160 int res1 = 0 ;
19161 bool temp2 = false ;
19162 PyObject * obj0 = 0 ;
19163 PyObject * obj1 = 0 ;
19164 char * kwnames[] = {
19165 (char *) "self",(char *) "s", NULL
19166 };
19167
19168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19172 }
19173 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19174 {
19175 arg2 = wxString_in_helper(obj1);
19176 if (arg2 == NULL) SWIG_fail;
19177 temp2 = true;
19178 }
19179 {
19180 PyThreadState* __tstate = wxPyBeginAllowThreads();
19181 (arg1)->SetString((wxString const &)*arg2);
19182 wxPyEndAllowThreads(__tstate);
19183 if (PyErr_Occurred()) SWIG_fail;
19184 }
19185 resultobj = SWIG_Py_Void();
19186 {
19187 if (temp2)
19188 delete arg2;
19189 }
19190 return resultobj;
19191 fail:
19192 {
19193 if (temp2)
19194 delete arg2;
19195 }
19196 return NULL;
19197 }
19198
19199
19200 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19201 PyObject *resultobj = 0;
19202 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19203 wxString result;
19204 void *argp1 = 0 ;
19205 int res1 = 0 ;
19206 PyObject *swig_obj[1] ;
19207
19208 if (!args) SWIG_fail;
19209 swig_obj[0] = args;
19210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19213 }
19214 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19215 {
19216 PyThreadState* __tstate = wxPyBeginAllowThreads();
19217 result = ((wxCommandEvent const *)arg1)->GetString();
19218 wxPyEndAllowThreads(__tstate);
19219 if (PyErr_Occurred()) SWIG_fail;
19220 }
19221 {
19222 #if wxUSE_UNICODE
19223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19224 #else
19225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19226 #endif
19227 }
19228 return resultobj;
19229 fail:
19230 return NULL;
19231 }
19232
19233
19234 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19235 PyObject *resultobj = 0;
19236 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19237 bool result;
19238 void *argp1 = 0 ;
19239 int res1 = 0 ;
19240 PyObject *swig_obj[1] ;
19241
19242 if (!args) SWIG_fail;
19243 swig_obj[0] = args;
19244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19245 if (!SWIG_IsOK(res1)) {
19246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19247 }
19248 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19249 {
19250 PyThreadState* __tstate = wxPyBeginAllowThreads();
19251 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 {
19256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19257 }
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19265 PyObject *resultobj = 0;
19266 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19267 bool result;
19268 void *argp1 = 0 ;
19269 int res1 = 0 ;
19270 PyObject *swig_obj[1] ;
19271
19272 if (!args) SWIG_fail;
19273 swig_obj[0] = args;
19274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19275 if (!SWIG_IsOK(res1)) {
19276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19277 }
19278 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19279 {
19280 PyThreadState* __tstate = wxPyBeginAllowThreads();
19281 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19282 wxPyEndAllowThreads(__tstate);
19283 if (PyErr_Occurred()) SWIG_fail;
19284 }
19285 {
19286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19287 }
19288 return resultobj;
19289 fail:
19290 return NULL;
19291 }
19292
19293
19294 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19295 PyObject *resultobj = 0;
19296 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19297 long arg2 ;
19298 void *argp1 = 0 ;
19299 int res1 = 0 ;
19300 long val2 ;
19301 int ecode2 = 0 ;
19302 PyObject * obj0 = 0 ;
19303 PyObject * obj1 = 0 ;
19304 char * kwnames[] = {
19305 (char *) "self",(char *) "extraLong", NULL
19306 };
19307
19308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19310 if (!SWIG_IsOK(res1)) {
19311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19312 }
19313 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19314 ecode2 = SWIG_AsVal_long(obj1, &val2);
19315 if (!SWIG_IsOK(ecode2)) {
19316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19317 }
19318 arg2 = static_cast< long >(val2);
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 (arg1)->SetExtraLong(arg2);
19322 wxPyEndAllowThreads(__tstate);
19323 if (PyErr_Occurred()) SWIG_fail;
19324 }
19325 resultobj = SWIG_Py_Void();
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333 PyObject *resultobj = 0;
19334 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19335 long result;
19336 void *argp1 = 0 ;
19337 int res1 = 0 ;
19338 PyObject *swig_obj[1] ;
19339
19340 if (!args) SWIG_fail;
19341 swig_obj[0] = args;
19342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19343 if (!SWIG_IsOK(res1)) {
19344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19345 }
19346 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19347 {
19348 PyThreadState* __tstate = wxPyBeginAllowThreads();
19349 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 resultobj = SWIG_From_long(static_cast< long >(result));
19354 return resultobj;
19355 fail:
19356 return NULL;
19357 }
19358
19359
19360 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19361 PyObject *resultobj = 0;
19362 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19363 int arg2 ;
19364 void *argp1 = 0 ;
19365 int res1 = 0 ;
19366 int val2 ;
19367 int ecode2 = 0 ;
19368 PyObject * obj0 = 0 ;
19369 PyObject * obj1 = 0 ;
19370 char * kwnames[] = {
19371 (char *) "self",(char *) "i", NULL
19372 };
19373
19374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19376 if (!SWIG_IsOK(res1)) {
19377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19378 }
19379 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19380 ecode2 = SWIG_AsVal_int(obj1, &val2);
19381 if (!SWIG_IsOK(ecode2)) {
19382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19383 }
19384 arg2 = static_cast< int >(val2);
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 (arg1)->SetInt(arg2);
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 resultobj = SWIG_Py_Void();
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19399 PyObject *resultobj = 0;
19400 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19401 int result;
19402 void *argp1 = 0 ;
19403 int res1 = 0 ;
19404 PyObject *swig_obj[1] ;
19405
19406 if (!args) SWIG_fail;
19407 swig_obj[0] = args;
19408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19409 if (!SWIG_IsOK(res1)) {
19410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19411 }
19412 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19413 {
19414 PyThreadState* __tstate = wxPyBeginAllowThreads();
19415 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 resultobj = SWIG_From_int(static_cast< int >(result));
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19427 PyObject *resultobj = 0;
19428 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19429 PyObject *result = 0 ;
19430 void *argp1 = 0 ;
19431 int res1 = 0 ;
19432 PyObject *swig_obj[1] ;
19433
19434 if (!args) SWIG_fail;
19435 swig_obj[0] = args;
19436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19437 if (!SWIG_IsOK(res1)) {
19438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19439 }
19440 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19444 wxPyEndAllowThreads(__tstate);
19445 if (PyErr_Occurred()) SWIG_fail;
19446 }
19447 resultobj = result;
19448 return resultobj;
19449 fail:
19450 return NULL;
19451 }
19452
19453
19454 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19455 PyObject *resultobj = 0;
19456 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19457 PyObject *arg2 = (PyObject *) 0 ;
19458 void *argp1 = 0 ;
19459 int res1 = 0 ;
19460 PyObject * obj0 = 0 ;
19461 PyObject * obj1 = 0 ;
19462 char * kwnames[] = {
19463 (char *) "self",(char *) "clientData", NULL
19464 };
19465
19466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19468 if (!SWIG_IsOK(res1)) {
19469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19470 }
19471 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19472 arg2 = obj1;
19473 {
19474 PyThreadState* __tstate = wxPyBeginAllowThreads();
19475 wxCommandEvent_SetClientData(arg1,arg2);
19476 wxPyEndAllowThreads(__tstate);
19477 if (PyErr_Occurred()) SWIG_fail;
19478 }
19479 resultobj = SWIG_Py_Void();
19480 return resultobj;
19481 fail:
19482 return NULL;
19483 }
19484
19485
19486 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19487 PyObject *resultobj = 0;
19488 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19489 wxEvent *result = 0 ;
19490 void *argp1 = 0 ;
19491 int res1 = 0 ;
19492 PyObject *swig_obj[1] ;
19493
19494 if (!args) SWIG_fail;
19495 swig_obj[0] = args;
19496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19497 if (!SWIG_IsOK(res1)) {
19498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19499 }
19500 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19501 {
19502 PyThreadState* __tstate = wxPyBeginAllowThreads();
19503 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19515 PyObject *obj;
19516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19517 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19518 return SWIG_Py_Void();
19519 }
19520
19521 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19522 return SWIG_Python_InitShadowInstance(args);
19523 }
19524
19525 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19526 PyObject *resultobj = 0;
19527 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19528 int arg2 = (int) 0 ;
19529 wxNotifyEvent *result = 0 ;
19530 int val1 ;
19531 int ecode1 = 0 ;
19532 int val2 ;
19533 int ecode2 = 0 ;
19534 PyObject * obj0 = 0 ;
19535 PyObject * obj1 = 0 ;
19536 char * kwnames[] = {
19537 (char *) "commandType",(char *) "winid", NULL
19538 };
19539
19540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19541 if (obj0) {
19542 ecode1 = SWIG_AsVal_int(obj0, &val1);
19543 if (!SWIG_IsOK(ecode1)) {
19544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19545 }
19546 arg1 = static_cast< wxEventType >(val1);
19547 }
19548 if (obj1) {
19549 ecode2 = SWIG_AsVal_int(obj1, &val2);
19550 if (!SWIG_IsOK(ecode2)) {
19551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19552 }
19553 arg2 = static_cast< int >(val2);
19554 }
19555 {
19556 PyThreadState* __tstate = wxPyBeginAllowThreads();
19557 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19558 wxPyEndAllowThreads(__tstate);
19559 if (PyErr_Occurred()) SWIG_fail;
19560 }
19561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19562 return resultobj;
19563 fail:
19564 return NULL;
19565 }
19566
19567
19568 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19569 PyObject *resultobj = 0;
19570 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19571 void *argp1 = 0 ;
19572 int res1 = 0 ;
19573 PyObject *swig_obj[1] ;
19574
19575 if (!args) SWIG_fail;
19576 swig_obj[0] = args;
19577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19578 if (!SWIG_IsOK(res1)) {
19579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19580 }
19581 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19582 {
19583 PyThreadState* __tstate = wxPyBeginAllowThreads();
19584 (arg1)->Veto();
19585 wxPyEndAllowThreads(__tstate);
19586 if (PyErr_Occurred()) SWIG_fail;
19587 }
19588 resultobj = SWIG_Py_Void();
19589 return resultobj;
19590 fail:
19591 return NULL;
19592 }
19593
19594
19595 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19596 PyObject *resultobj = 0;
19597 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19598 void *argp1 = 0 ;
19599 int res1 = 0 ;
19600 PyObject *swig_obj[1] ;
19601
19602 if (!args) SWIG_fail;
19603 swig_obj[0] = args;
19604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19605 if (!SWIG_IsOK(res1)) {
19606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19607 }
19608 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19609 {
19610 PyThreadState* __tstate = wxPyBeginAllowThreads();
19611 (arg1)->Allow();
19612 wxPyEndAllowThreads(__tstate);
19613 if (PyErr_Occurred()) SWIG_fail;
19614 }
19615 resultobj = SWIG_Py_Void();
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19623 PyObject *resultobj = 0;
19624 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19625 bool result;
19626 void *argp1 = 0 ;
19627 int res1 = 0 ;
19628 PyObject *swig_obj[1] ;
19629
19630 if (!args) SWIG_fail;
19631 swig_obj[0] = args;
19632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19633 if (!SWIG_IsOK(res1)) {
19634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19635 }
19636 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19637 {
19638 PyThreadState* __tstate = wxPyBeginAllowThreads();
19639 result = (bool)(arg1)->IsAllowed();
19640 wxPyEndAllowThreads(__tstate);
19641 if (PyErr_Occurred()) SWIG_fail;
19642 }
19643 {
19644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19645 }
19646 return resultobj;
19647 fail:
19648 return NULL;
19649 }
19650
19651
19652 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19653 PyObject *obj;
19654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19655 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19656 return SWIG_Py_Void();
19657 }
19658
19659 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19660 return SWIG_Python_InitShadowInstance(args);
19661 }
19662
19663 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj = 0;
19665 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19666 int arg2 = (int) 0 ;
19667 int arg3 = (int) 0 ;
19668 int arg4 = (int) 0 ;
19669 wxScrollEvent *result = 0 ;
19670 int val1 ;
19671 int ecode1 = 0 ;
19672 int val2 ;
19673 int ecode2 = 0 ;
19674 int val3 ;
19675 int ecode3 = 0 ;
19676 int val4 ;
19677 int ecode4 = 0 ;
19678 PyObject * obj0 = 0 ;
19679 PyObject * obj1 = 0 ;
19680 PyObject * obj2 = 0 ;
19681 PyObject * obj3 = 0 ;
19682 char * kwnames[] = {
19683 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19684 };
19685
19686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19687 if (obj0) {
19688 ecode1 = SWIG_AsVal_int(obj0, &val1);
19689 if (!SWIG_IsOK(ecode1)) {
19690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19691 }
19692 arg1 = static_cast< wxEventType >(val1);
19693 }
19694 if (obj1) {
19695 ecode2 = SWIG_AsVal_int(obj1, &val2);
19696 if (!SWIG_IsOK(ecode2)) {
19697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19698 }
19699 arg2 = static_cast< int >(val2);
19700 }
19701 if (obj2) {
19702 ecode3 = SWIG_AsVal_int(obj2, &val3);
19703 if (!SWIG_IsOK(ecode3)) {
19704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19705 }
19706 arg3 = static_cast< int >(val3);
19707 }
19708 if (obj3) {
19709 ecode4 = SWIG_AsVal_int(obj3, &val4);
19710 if (!SWIG_IsOK(ecode4)) {
19711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19712 }
19713 arg4 = static_cast< int >(val4);
19714 }
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19729 PyObject *resultobj = 0;
19730 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19731 int result;
19732 void *argp1 = 0 ;
19733 int res1 = 0 ;
19734 PyObject *swig_obj[1] ;
19735
19736 if (!args) SWIG_fail;
19737 swig_obj[0] = args;
19738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19739 if (!SWIG_IsOK(res1)) {
19740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19741 }
19742 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_From_int(static_cast< int >(result));
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 PyObject *resultobj = 0;
19758 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19759 int result;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 PyObject *swig_obj[1] ;
19763
19764 if (!args) SWIG_fail;
19765 swig_obj[0] = args;
19766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19767 if (!SWIG_IsOK(res1)) {
19768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19769 }
19770 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 resultobj = SWIG_From_int(static_cast< int >(result));
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19785 PyObject *resultobj = 0;
19786 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19787 int arg2 ;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 int val2 ;
19791 int ecode2 = 0 ;
19792 PyObject * obj0 = 0 ;
19793 PyObject * obj1 = 0 ;
19794 char * kwnames[] = {
19795 (char *) "self",(char *) "orient", NULL
19796 };
19797
19798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19800 if (!SWIG_IsOK(res1)) {
19801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19802 }
19803 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19804 ecode2 = SWIG_AsVal_int(obj1, &val2);
19805 if (!SWIG_IsOK(ecode2)) {
19806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19807 }
19808 arg2 = static_cast< int >(val2);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->SetOrientation(arg2);
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 resultobj = SWIG_Py_Void();
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19825 int arg2 ;
19826 void *argp1 = 0 ;
19827 int res1 = 0 ;
19828 int val2 ;
19829 int ecode2 = 0 ;
19830 PyObject * obj0 = 0 ;
19831 PyObject * obj1 = 0 ;
19832 char * kwnames[] = {
19833 (char *) "self",(char *) "pos", NULL
19834 };
19835
19836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19838 if (!SWIG_IsOK(res1)) {
19839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19840 }
19841 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19842 ecode2 = SWIG_AsVal_int(obj1, &val2);
19843 if (!SWIG_IsOK(ecode2)) {
19844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19845 }
19846 arg2 = static_cast< int >(val2);
19847 {
19848 PyThreadState* __tstate = wxPyBeginAllowThreads();
19849 (arg1)->SetPosition(arg2);
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_Py_Void();
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19861 PyObject *obj;
19862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19863 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19864 return SWIG_Py_Void();
19865 }
19866
19867 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19868 return SWIG_Python_InitShadowInstance(args);
19869 }
19870
19871 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj = 0;
19873 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19874 int arg2 = (int) 0 ;
19875 int arg3 = (int) 0 ;
19876 wxScrollWinEvent *result = 0 ;
19877 int val1 ;
19878 int ecode1 = 0 ;
19879 int val2 ;
19880 int ecode2 = 0 ;
19881 int val3 ;
19882 int ecode3 = 0 ;
19883 PyObject * obj0 = 0 ;
19884 PyObject * obj1 = 0 ;
19885 PyObject * obj2 = 0 ;
19886 char * kwnames[] = {
19887 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19888 };
19889
19890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19891 if (obj0) {
19892 ecode1 = SWIG_AsVal_int(obj0, &val1);
19893 if (!SWIG_IsOK(ecode1)) {
19894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19895 }
19896 arg1 = static_cast< wxEventType >(val1);
19897 }
19898 if (obj1) {
19899 ecode2 = SWIG_AsVal_int(obj1, &val2);
19900 if (!SWIG_IsOK(ecode2)) {
19901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19902 }
19903 arg2 = static_cast< int >(val2);
19904 }
19905 if (obj2) {
19906 ecode3 = SWIG_AsVal_int(obj2, &val3);
19907 if (!SWIG_IsOK(ecode3)) {
19908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19909 }
19910 arg3 = static_cast< int >(val3);
19911 }
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19915 wxPyEndAllowThreads(__tstate);
19916 if (PyErr_Occurred()) SWIG_fail;
19917 }
19918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19919 return resultobj;
19920 fail:
19921 return NULL;
19922 }
19923
19924
19925 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19926 PyObject *resultobj = 0;
19927 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19928 int result;
19929 void *argp1 = 0 ;
19930 int res1 = 0 ;
19931 PyObject *swig_obj[1] ;
19932
19933 if (!args) SWIG_fail;
19934 swig_obj[0] = args;
19935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19936 if (!SWIG_IsOK(res1)) {
19937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19938 }
19939 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19940 {
19941 PyThreadState* __tstate = wxPyBeginAllowThreads();
19942 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19943 wxPyEndAllowThreads(__tstate);
19944 if (PyErr_Occurred()) SWIG_fail;
19945 }
19946 resultobj = SWIG_From_int(static_cast< int >(result));
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19954 PyObject *resultobj = 0;
19955 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19956 int result;
19957 void *argp1 = 0 ;
19958 int res1 = 0 ;
19959 PyObject *swig_obj[1] ;
19960
19961 if (!args) SWIG_fail;
19962 swig_obj[0] = args;
19963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19964 if (!SWIG_IsOK(res1)) {
19965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19966 }
19967 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19968 {
19969 PyThreadState* __tstate = wxPyBeginAllowThreads();
19970 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 resultobj = SWIG_From_int(static_cast< int >(result));
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19982 PyObject *resultobj = 0;
19983 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19984 int arg2 ;
19985 void *argp1 = 0 ;
19986 int res1 = 0 ;
19987 int val2 ;
19988 int ecode2 = 0 ;
19989 PyObject * obj0 = 0 ;
19990 PyObject * obj1 = 0 ;
19991 char * kwnames[] = {
19992 (char *) "self",(char *) "orient", NULL
19993 };
19994
19995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19997 if (!SWIG_IsOK(res1)) {
19998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19999 }
20000 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20001 ecode2 = SWIG_AsVal_int(obj1, &val2);
20002 if (!SWIG_IsOK(ecode2)) {
20003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20004 }
20005 arg2 = static_cast< int >(val2);
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 (arg1)->SetOrientation(arg2);
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 resultobj = SWIG_Py_Void();
20013 return resultobj;
20014 fail:
20015 return NULL;
20016 }
20017
20018
20019 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20020 PyObject *resultobj = 0;
20021 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20022 int arg2 ;
20023 void *argp1 = 0 ;
20024 int res1 = 0 ;
20025 int val2 ;
20026 int ecode2 = 0 ;
20027 PyObject * obj0 = 0 ;
20028 PyObject * obj1 = 0 ;
20029 char * kwnames[] = {
20030 (char *) "self",(char *) "pos", NULL
20031 };
20032
20033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20035 if (!SWIG_IsOK(res1)) {
20036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20037 }
20038 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20039 ecode2 = SWIG_AsVal_int(obj1, &val2);
20040 if (!SWIG_IsOK(ecode2)) {
20041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20042 }
20043 arg2 = static_cast< int >(val2);
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 (arg1)->SetPosition(arg2);
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 resultobj = SWIG_Py_Void();
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20058 PyObject *obj;
20059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20060 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20061 return SWIG_Py_Void();
20062 }
20063
20064 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20065 return SWIG_Python_InitShadowInstance(args);
20066 }
20067
20068 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20069 PyObject *resultobj = 0;
20070 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20071 wxMouseEvent *result = 0 ;
20072 int val1 ;
20073 int ecode1 = 0 ;
20074 PyObject * obj0 = 0 ;
20075 char * kwnames[] = {
20076 (char *) "mouseType", NULL
20077 };
20078
20079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20080 if (obj0) {
20081 ecode1 = SWIG_AsVal_int(obj0, &val1);
20082 if (!SWIG_IsOK(ecode1)) {
20083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20084 }
20085 arg1 = static_cast< wxEventType >(val1);
20086 }
20087 {
20088 PyThreadState* __tstate = wxPyBeginAllowThreads();
20089 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20090 wxPyEndAllowThreads(__tstate);
20091 if (PyErr_Occurred()) SWIG_fail;
20092 }
20093 {
20094 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20095 }
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20103 PyObject *resultobj = 0;
20104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20105 bool result;
20106 void *argp1 = 0 ;
20107 int res1 = 0 ;
20108 PyObject *swig_obj[1] ;
20109
20110 if (!args) SWIG_fail;
20111 swig_obj[0] = args;
20112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20113 if (!SWIG_IsOK(res1)) {
20114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20115 }
20116 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 {
20124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj = 0;
20134 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20135 int arg2 = (int) wxMOUSE_BTN_ANY ;
20136 bool result;
20137 void *argp1 = 0 ;
20138 int res1 = 0 ;
20139 int val2 ;
20140 int ecode2 = 0 ;
20141 PyObject * obj0 = 0 ;
20142 PyObject * obj1 = 0 ;
20143 char * kwnames[] = {
20144 (char *) "self",(char *) "but", NULL
20145 };
20146
20147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20149 if (!SWIG_IsOK(res1)) {
20150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20151 }
20152 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20153 if (obj1) {
20154 ecode2 = SWIG_AsVal_int(obj1, &val2);
20155 if (!SWIG_IsOK(ecode2)) {
20156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20157 }
20158 arg2 = static_cast< int >(val2);
20159 }
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 {
20167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20168 }
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20176 PyObject *resultobj = 0;
20177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20178 int arg2 = (int) wxMOUSE_BTN_ANY ;
20179 bool result;
20180 void *argp1 = 0 ;
20181 int res1 = 0 ;
20182 int val2 ;
20183 int ecode2 = 0 ;
20184 PyObject * obj0 = 0 ;
20185 PyObject * obj1 = 0 ;
20186 char * kwnames[] = {
20187 (char *) "self",(char *) "but", NULL
20188 };
20189
20190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20192 if (!SWIG_IsOK(res1)) {
20193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20194 }
20195 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20196 if (obj1) {
20197 ecode2 = SWIG_AsVal_int(obj1, &val2);
20198 if (!SWIG_IsOK(ecode2)) {
20199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20200 }
20201 arg2 = static_cast< int >(val2);
20202 }
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20206 wxPyEndAllowThreads(__tstate);
20207 if (PyErr_Occurred()) SWIG_fail;
20208 }
20209 {
20210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20211 }
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20219 PyObject *resultobj = 0;
20220 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20221 int arg2 = (int) wxMOUSE_BTN_ANY ;
20222 bool result;
20223 void *argp1 = 0 ;
20224 int res1 = 0 ;
20225 int val2 ;
20226 int ecode2 = 0 ;
20227 PyObject * obj0 = 0 ;
20228 PyObject * obj1 = 0 ;
20229 char * kwnames[] = {
20230 (char *) "self",(char *) "but", NULL
20231 };
20232
20233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20235 if (!SWIG_IsOK(res1)) {
20236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20237 }
20238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20239 if (obj1) {
20240 ecode2 = SWIG_AsVal_int(obj1, &val2);
20241 if (!SWIG_IsOK(ecode2)) {
20242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20243 }
20244 arg2 = static_cast< int >(val2);
20245 }
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 {
20253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20254 }
20255 return resultobj;
20256 fail:
20257 return NULL;
20258 }
20259
20260
20261 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20262 PyObject *resultobj = 0;
20263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20264 int arg2 ;
20265 bool result;
20266 void *argp1 = 0 ;
20267 int res1 = 0 ;
20268 int val2 ;
20269 int ecode2 = 0 ;
20270 PyObject * obj0 = 0 ;
20271 PyObject * obj1 = 0 ;
20272 char * kwnames[] = {
20273 (char *) "self",(char *) "button", NULL
20274 };
20275
20276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20278 if (!SWIG_IsOK(res1)) {
20279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20280 }
20281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20282 ecode2 = SWIG_AsVal_int(obj1, &val2);
20283 if (!SWIG_IsOK(ecode2)) {
20284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20285 }
20286 arg2 = static_cast< int >(val2);
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20290 wxPyEndAllowThreads(__tstate);
20291 if (PyErr_Occurred()) SWIG_fail;
20292 }
20293 {
20294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20295 }
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20303 PyObject *resultobj = 0;
20304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20305 int arg2 ;
20306 bool result;
20307 void *argp1 = 0 ;
20308 int res1 = 0 ;
20309 int val2 ;
20310 int ecode2 = 0 ;
20311 PyObject * obj0 = 0 ;
20312 PyObject * obj1 = 0 ;
20313 char * kwnames[] = {
20314 (char *) "self",(char *) "but", NULL
20315 };
20316
20317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20319 if (!SWIG_IsOK(res1)) {
20320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20321 }
20322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20323 ecode2 = SWIG_AsVal_int(obj1, &val2);
20324 if (!SWIG_IsOK(ecode2)) {
20325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20326 }
20327 arg2 = static_cast< int >(val2);
20328 {
20329 PyThreadState* __tstate = wxPyBeginAllowThreads();
20330 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20331 wxPyEndAllowThreads(__tstate);
20332 if (PyErr_Occurred()) SWIG_fail;
20333 }
20334 {
20335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20336 }
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20344 PyObject *resultobj = 0;
20345 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20346 int result;
20347 void *argp1 = 0 ;
20348 int res1 = 0 ;
20349 PyObject *swig_obj[1] ;
20350
20351 if (!args) SWIG_fail;
20352 swig_obj[0] = args;
20353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20354 if (!SWIG_IsOK(res1)) {
20355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20356 }
20357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 resultobj = SWIG_From_int(static_cast< int >(result));
20365 return resultobj;
20366 fail:
20367 return NULL;
20368 }
20369
20370
20371 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20372 PyObject *resultobj = 0;
20373 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20374 bool result;
20375 void *argp1 = 0 ;
20376 int res1 = 0 ;
20377 PyObject *swig_obj[1] ;
20378
20379 if (!args) SWIG_fail;
20380 swig_obj[0] = args;
20381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20382 if (!SWIG_IsOK(res1)) {
20383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20384 }
20385 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20386 {
20387 PyThreadState* __tstate = wxPyBeginAllowThreads();
20388 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 {
20393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20394 }
20395 return resultobj;
20396 fail:
20397 return NULL;
20398 }
20399
20400
20401 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20402 PyObject *resultobj = 0;
20403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20404 bool result;
20405 void *argp1 = 0 ;
20406 int res1 = 0 ;
20407 PyObject *swig_obj[1] ;
20408
20409 if (!args) SWIG_fail;
20410 swig_obj[0] = args;
20411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20412 if (!SWIG_IsOK(res1)) {
20413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20414 }
20415 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20416 {
20417 PyThreadState* __tstate = wxPyBeginAllowThreads();
20418 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 {
20423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20424 }
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20432 PyObject *resultobj = 0;
20433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20434 bool result;
20435 void *argp1 = 0 ;
20436 int res1 = 0 ;
20437 PyObject *swig_obj[1] ;
20438
20439 if (!args) SWIG_fail;
20440 swig_obj[0] = args;
20441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20442 if (!SWIG_IsOK(res1)) {
20443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20444 }
20445 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20446 {
20447 PyThreadState* __tstate = wxPyBeginAllowThreads();
20448 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20449 wxPyEndAllowThreads(__tstate);
20450 if (PyErr_Occurred()) SWIG_fail;
20451 }
20452 {
20453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20454 }
20455 return resultobj;
20456 fail:
20457 return NULL;
20458 }
20459
20460
20461 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20462 PyObject *resultobj = 0;
20463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20464 bool result;
20465 void *argp1 = 0 ;
20466 int res1 = 0 ;
20467 PyObject *swig_obj[1] ;
20468
20469 if (!args) SWIG_fail;
20470 swig_obj[0] = args;
20471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20472 if (!SWIG_IsOK(res1)) {
20473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20474 }
20475 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 {
20483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20484 }
20485 return resultobj;
20486 fail:
20487 return NULL;
20488 }
20489
20490
20491 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20492 PyObject *resultobj = 0;
20493 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20494 bool result;
20495 void *argp1 = 0 ;
20496 int res1 = 0 ;
20497 PyObject *swig_obj[1] ;
20498
20499 if (!args) SWIG_fail;
20500 swig_obj[0] = args;
20501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20502 if (!SWIG_IsOK(res1)) {
20503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20504 }
20505 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20506 {
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20509 wxPyEndAllowThreads(__tstate);
20510 if (PyErr_Occurred()) SWIG_fail;
20511 }
20512 {
20513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20514 }
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20522 PyObject *resultobj = 0;
20523 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20524 bool result;
20525 void *argp1 = 0 ;
20526 int res1 = 0 ;
20527 PyObject *swig_obj[1] ;
20528
20529 if (!args) SWIG_fail;
20530 swig_obj[0] = args;
20531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20532 if (!SWIG_IsOK(res1)) {
20533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20534 }
20535 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20536 {
20537 PyThreadState* __tstate = wxPyBeginAllowThreads();
20538 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 {
20543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20544 }
20545 return resultobj;
20546 fail:
20547 return NULL;
20548 }
20549
20550
20551 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20552 PyObject *resultobj = 0;
20553 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20554 bool result;
20555 void *argp1 = 0 ;
20556 int res1 = 0 ;
20557 PyObject *swig_obj[1] ;
20558
20559 if (!args) SWIG_fail;
20560 swig_obj[0] = args;
20561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20562 if (!SWIG_IsOK(res1)) {
20563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20564 }
20565 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20566 {
20567 PyThreadState* __tstate = wxPyBeginAllowThreads();
20568 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20569 wxPyEndAllowThreads(__tstate);
20570 if (PyErr_Occurred()) SWIG_fail;
20571 }
20572 {
20573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20574 }
20575 return resultobj;
20576 fail:
20577 return NULL;
20578 }
20579
20580
20581 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20582 PyObject *resultobj = 0;
20583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20584 bool result;
20585 void *argp1 = 0 ;
20586 int res1 = 0 ;
20587 PyObject *swig_obj[1] ;
20588
20589 if (!args) SWIG_fail;
20590 swig_obj[0] = args;
20591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20592 if (!SWIG_IsOK(res1)) {
20593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20594 }
20595 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20596 {
20597 PyThreadState* __tstate = wxPyBeginAllowThreads();
20598 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 {
20603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20604 }
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20612 PyObject *resultobj = 0;
20613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20614 bool result;
20615 void *argp1 = 0 ;
20616 int res1 = 0 ;
20617 PyObject *swig_obj[1] ;
20618
20619 if (!args) SWIG_fail;
20620 swig_obj[0] = args;
20621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20622 if (!SWIG_IsOK(res1)) {
20623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20624 }
20625 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20626 {
20627 PyThreadState* __tstate = wxPyBeginAllowThreads();
20628 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20629 wxPyEndAllowThreads(__tstate);
20630 if (PyErr_Occurred()) SWIG_fail;
20631 }
20632 {
20633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20634 }
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20642 PyObject *resultobj = 0;
20643 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20644 bool result;
20645 void *argp1 = 0 ;
20646 int res1 = 0 ;
20647 PyObject *swig_obj[1] ;
20648
20649 if (!args) SWIG_fail;
20650 swig_obj[0] = args;
20651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20652 if (!SWIG_IsOK(res1)) {
20653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20654 }
20655 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 {
20663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20664 }
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20672 PyObject *resultobj = 0;
20673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20674 bool result;
20675 void *argp1 = 0 ;
20676 int res1 = 0 ;
20677 PyObject *swig_obj[1] ;
20678
20679 if (!args) SWIG_fail;
20680 swig_obj[0] = args;
20681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20682 if (!SWIG_IsOK(res1)) {
20683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20684 }
20685 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 {
20693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20694 }
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20702 PyObject *resultobj = 0;
20703 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20704 bool result;
20705 void *argp1 = 0 ;
20706 int res1 = 0 ;
20707 PyObject *swig_obj[1] ;
20708
20709 if (!args) SWIG_fail;
20710 swig_obj[0] = args;
20711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20712 if (!SWIG_IsOK(res1)) {
20713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20714 }
20715 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20716 {
20717 PyThreadState* __tstate = wxPyBeginAllowThreads();
20718 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20719 wxPyEndAllowThreads(__tstate);
20720 if (PyErr_Occurred()) SWIG_fail;
20721 }
20722 {
20723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20724 }
20725 return resultobj;
20726 fail:
20727 return NULL;
20728 }
20729
20730
20731 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20732 PyObject *resultobj = 0;
20733 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20734 bool result;
20735 void *argp1 = 0 ;
20736 int res1 = 0 ;
20737 PyObject *swig_obj[1] ;
20738
20739 if (!args) SWIG_fail;
20740 swig_obj[0] = args;
20741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20742 if (!SWIG_IsOK(res1)) {
20743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20744 }
20745 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20749 wxPyEndAllowThreads(__tstate);
20750 if (PyErr_Occurred()) SWIG_fail;
20751 }
20752 {
20753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20754 }
20755 return resultobj;
20756 fail:
20757 return NULL;
20758 }
20759
20760
20761 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20762 PyObject *resultobj = 0;
20763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20764 bool result;
20765 void *argp1 = 0 ;
20766 int res1 = 0 ;
20767 PyObject *swig_obj[1] ;
20768
20769 if (!args) SWIG_fail;
20770 swig_obj[0] = args;
20771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20772 if (!SWIG_IsOK(res1)) {
20773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20774 }
20775 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20776 {
20777 PyThreadState* __tstate = wxPyBeginAllowThreads();
20778 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 {
20783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20784 }
20785 return resultobj;
20786 fail:
20787 return NULL;
20788 }
20789
20790
20791 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20792 PyObject *resultobj = 0;
20793 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20794 bool result;
20795 void *argp1 = 0 ;
20796 int res1 = 0 ;
20797 PyObject *swig_obj[1] ;
20798
20799 if (!args) SWIG_fail;
20800 swig_obj[0] = args;
20801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20802 if (!SWIG_IsOK(res1)) {
20803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20804 }
20805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = (bool)(arg1)->LeftIsDown();
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 {
20813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20814 }
20815 return resultobj;
20816 fail:
20817 return NULL;
20818 }
20819
20820
20821 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20822 PyObject *resultobj = 0;
20823 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20824 bool result;
20825 void *argp1 = 0 ;
20826 int res1 = 0 ;
20827 PyObject *swig_obj[1] ;
20828
20829 if (!args) SWIG_fail;
20830 swig_obj[0] = args;
20831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20832 if (!SWIG_IsOK(res1)) {
20833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20834 }
20835 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (bool)(arg1)->MiddleIsDown();
20839 wxPyEndAllowThreads(__tstate);
20840 if (PyErr_Occurred()) SWIG_fail;
20841 }
20842 {
20843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20844 }
20845 return resultobj;
20846 fail:
20847 return NULL;
20848 }
20849
20850
20851 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20852 PyObject *resultobj = 0;
20853 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20854 bool result;
20855 void *argp1 = 0 ;
20856 int res1 = 0 ;
20857 PyObject *swig_obj[1] ;
20858
20859 if (!args) SWIG_fail;
20860 swig_obj[0] = args;
20861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20862 if (!SWIG_IsOK(res1)) {
20863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20864 }
20865 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20866 {
20867 PyThreadState* __tstate = wxPyBeginAllowThreads();
20868 result = (bool)(arg1)->RightIsDown();
20869 wxPyEndAllowThreads(__tstate);
20870 if (PyErr_Occurred()) SWIG_fail;
20871 }
20872 {
20873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20874 }
20875 return resultobj;
20876 fail:
20877 return NULL;
20878 }
20879
20880
20881 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20882 PyObject *resultobj = 0;
20883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20884 bool result;
20885 void *argp1 = 0 ;
20886 int res1 = 0 ;
20887 PyObject *swig_obj[1] ;
20888
20889 if (!args) SWIG_fail;
20890 swig_obj[0] = args;
20891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20892 if (!SWIG_IsOK(res1)) {
20893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20894 }
20895 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20899 wxPyEndAllowThreads(__tstate);
20900 if (PyErr_Occurred()) SWIG_fail;
20901 }
20902 {
20903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20904 }
20905 return resultobj;
20906 fail:
20907 return NULL;
20908 }
20909
20910
20911 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20912 PyObject *resultobj = 0;
20913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20914 bool result;
20915 void *argp1 = 0 ;
20916 int res1 = 0 ;
20917 PyObject *swig_obj[1] ;
20918
20919 if (!args) SWIG_fail;
20920 swig_obj[0] = args;
20921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20922 if (!SWIG_IsOK(res1)) {
20923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20924 }
20925 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20929 wxPyEndAllowThreads(__tstate);
20930 if (PyErr_Occurred()) SWIG_fail;
20931 }
20932 {
20933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20934 }
20935 return resultobj;
20936 fail:
20937 return NULL;
20938 }
20939
20940
20941 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20942 PyObject *resultobj = 0;
20943 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20944 bool result;
20945 void *argp1 = 0 ;
20946 int res1 = 0 ;
20947 PyObject *swig_obj[1] ;
20948
20949 if (!args) SWIG_fail;
20950 swig_obj[0] = args;
20951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20952 if (!SWIG_IsOK(res1)) {
20953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20954 }
20955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20959 wxPyEndAllowThreads(__tstate);
20960 if (PyErr_Occurred()) SWIG_fail;
20961 }
20962 {
20963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20964 }
20965 return resultobj;
20966 fail:
20967 return NULL;
20968 }
20969
20970
20971 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20972 PyObject *resultobj = 0;
20973 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20974 bool result;
20975 void *argp1 = 0 ;
20976 int res1 = 0 ;
20977 PyObject *swig_obj[1] ;
20978
20979 if (!args) SWIG_fail;
20980 swig_obj[0] = args;
20981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20982 if (!SWIG_IsOK(res1)) {
20983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20984 }
20985 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20989 wxPyEndAllowThreads(__tstate);
20990 if (PyErr_Occurred()) SWIG_fail;
20991 }
20992 {
20993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20994 }
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21002 PyObject *resultobj = 0;
21003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21004 wxPoint result;
21005 void *argp1 = 0 ;
21006 int res1 = 0 ;
21007 PyObject *swig_obj[1] ;
21008
21009 if (!args) SWIG_fail;
21010 swig_obj[0] = args;
21011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21012 if (!SWIG_IsOK(res1)) {
21013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21014 }
21015 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21016 {
21017 PyThreadState* __tstate = wxPyBeginAllowThreads();
21018 result = (arg1)->GetPosition();
21019 wxPyEndAllowThreads(__tstate);
21020 if (PyErr_Occurred()) SWIG_fail;
21021 }
21022 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *resultobj = 0;
21031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21032 long *arg2 = (long *) 0 ;
21033 long *arg3 = (long *) 0 ;
21034 void *argp1 = 0 ;
21035 int res1 = 0 ;
21036 long temp2 ;
21037 int res2 = SWIG_TMPOBJ ;
21038 long temp3 ;
21039 int res3 = SWIG_TMPOBJ ;
21040 PyObject *swig_obj[1] ;
21041
21042 arg2 = &temp2;
21043 arg3 = &temp3;
21044 if (!args) SWIG_fail;
21045 swig_obj[0] = args;
21046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21047 if (!SWIG_IsOK(res1)) {
21048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21049 }
21050 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21051 {
21052 PyThreadState* __tstate = wxPyBeginAllowThreads();
21053 (arg1)->GetPosition(arg2,arg3);
21054 wxPyEndAllowThreads(__tstate);
21055 if (PyErr_Occurred()) SWIG_fail;
21056 }
21057 resultobj = SWIG_Py_Void();
21058 if (SWIG_IsTmpObj(res2)) {
21059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21060 } else {
21061 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21063 }
21064 if (SWIG_IsTmpObj(res3)) {
21065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21066 } else {
21067 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21077 PyObject *resultobj = 0;
21078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21079 wxDC *arg2 = 0 ;
21080 wxPoint result;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 void *argp2 = 0 ;
21084 int res2 = 0 ;
21085 PyObject * obj0 = 0 ;
21086 PyObject * obj1 = 0 ;
21087 char * kwnames[] = {
21088 (char *) "self",(char *) "dc", NULL
21089 };
21090
21091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21093 if (!SWIG_IsOK(res1)) {
21094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21095 }
21096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21098 if (!SWIG_IsOK(res2)) {
21099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21100 }
21101 if (!argp2) {
21102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21103 }
21104 arg2 = reinterpret_cast< wxDC * >(argp2);
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21108 wxPyEndAllowThreads(__tstate);
21109 if (PyErr_Occurred()) SWIG_fail;
21110 }
21111 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21119 PyObject *resultobj = 0;
21120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21121 int result;
21122 void *argp1 = 0 ;
21123 int res1 = 0 ;
21124 PyObject *swig_obj[1] ;
21125
21126 if (!args) SWIG_fail;
21127 swig_obj[0] = args;
21128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21129 if (!SWIG_IsOK(res1)) {
21130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21131 }
21132 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 result = (int)((wxMouseEvent const *)arg1)->GetX();
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 resultobj = SWIG_From_int(static_cast< int >(result));
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21147 PyObject *resultobj = 0;
21148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21149 int result;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 PyObject *swig_obj[1] ;
21153
21154 if (!args) SWIG_fail;
21155 swig_obj[0] = args;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21159 }
21160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 result = (int)((wxMouseEvent const *)arg1)->GetY();
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 resultobj = SWIG_From_int(static_cast< int >(result));
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21177 int result;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 PyObject *swig_obj[1] ;
21181
21182 if (!args) SWIG_fail;
21183 swig_obj[0] = args;
21184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21187 }
21188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 resultobj = SWIG_From_int(static_cast< int >(result));
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21203 PyObject *resultobj = 0;
21204 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21205 int result;
21206 void *argp1 = 0 ;
21207 int res1 = 0 ;
21208 PyObject *swig_obj[1] ;
21209
21210 if (!args) SWIG_fail;
21211 swig_obj[0] = args;
21212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21213 if (!SWIG_IsOK(res1)) {
21214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21215 }
21216 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21217 {
21218 PyThreadState* __tstate = wxPyBeginAllowThreads();
21219 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 resultobj = SWIG_From_int(static_cast< int >(result));
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21231 PyObject *resultobj = 0;
21232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21233 int result;
21234 void *argp1 = 0 ;
21235 int res1 = 0 ;
21236 PyObject *swig_obj[1] ;
21237
21238 if (!args) SWIG_fail;
21239 swig_obj[0] = args;
21240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21241 if (!SWIG_IsOK(res1)) {
21242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21243 }
21244 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 resultobj = SWIG_From_int(static_cast< int >(result));
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21259 PyObject *resultobj = 0;
21260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21261 bool result;
21262 void *argp1 = 0 ;
21263 int res1 = 0 ;
21264 PyObject *swig_obj[1] ;
21265
21266 if (!args) SWIG_fail;
21267 swig_obj[0] = args;
21268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21271 }
21272 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21273 {
21274 PyThreadState* __tstate = wxPyBeginAllowThreads();
21275 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21276 wxPyEndAllowThreads(__tstate);
21277 if (PyErr_Occurred()) SWIG_fail;
21278 }
21279 {
21280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21281 }
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21289 PyObject *resultobj = 0;
21290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21291 int arg2 ;
21292 void *argp1 = 0 ;
21293 int res1 = 0 ;
21294 int val2 ;
21295 int ecode2 = 0 ;
21296 PyObject *swig_obj[2] ;
21297
21298 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21300 if (!SWIG_IsOK(res1)) {
21301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21302 }
21303 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21304 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21305 if (!SWIG_IsOK(ecode2)) {
21306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21307 }
21308 arg2 = static_cast< int >(val2);
21309 if (arg1) (arg1)->m_x = arg2;
21310
21311 resultobj = SWIG_Py_Void();
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21319 PyObject *resultobj = 0;
21320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21321 int result;
21322 void *argp1 = 0 ;
21323 int res1 = 0 ;
21324 PyObject *swig_obj[1] ;
21325
21326 if (!args) SWIG_fail;
21327 swig_obj[0] = args;
21328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21329 if (!SWIG_IsOK(res1)) {
21330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21331 }
21332 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21333 result = (int) ((arg1)->m_x);
21334 resultobj = SWIG_From_int(static_cast< int >(result));
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21342 PyObject *resultobj = 0;
21343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21344 int arg2 ;
21345 void *argp1 = 0 ;
21346 int res1 = 0 ;
21347 int val2 ;
21348 int ecode2 = 0 ;
21349 PyObject *swig_obj[2] ;
21350
21351 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21353 if (!SWIG_IsOK(res1)) {
21354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21355 }
21356 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21357 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21358 if (!SWIG_IsOK(ecode2)) {
21359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21360 }
21361 arg2 = static_cast< int >(val2);
21362 if (arg1) (arg1)->m_y = arg2;
21363
21364 resultobj = SWIG_Py_Void();
21365 return resultobj;
21366 fail:
21367 return NULL;
21368 }
21369
21370
21371 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21372 PyObject *resultobj = 0;
21373 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21374 int result;
21375 void *argp1 = 0 ;
21376 int res1 = 0 ;
21377 PyObject *swig_obj[1] ;
21378
21379 if (!args) SWIG_fail;
21380 swig_obj[0] = args;
21381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21382 if (!SWIG_IsOK(res1)) {
21383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21384 }
21385 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21386 result = (int) ((arg1)->m_y);
21387 resultobj = SWIG_From_int(static_cast< int >(result));
21388 return resultobj;
21389 fail:
21390 return NULL;
21391 }
21392
21393
21394 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21395 PyObject *resultobj = 0;
21396 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21397 bool arg2 ;
21398 void *argp1 = 0 ;
21399 int res1 = 0 ;
21400 bool val2 ;
21401 int ecode2 = 0 ;
21402 PyObject *swig_obj[2] ;
21403
21404 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21406 if (!SWIG_IsOK(res1)) {
21407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21408 }
21409 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21410 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21411 if (!SWIG_IsOK(ecode2)) {
21412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21413 }
21414 arg2 = static_cast< bool >(val2);
21415 if (arg1) (arg1)->m_leftDown = arg2;
21416
21417 resultobj = SWIG_Py_Void();
21418 return resultobj;
21419 fail:
21420 return NULL;
21421 }
21422
21423
21424 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21425 PyObject *resultobj = 0;
21426 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21427 bool result;
21428 void *argp1 = 0 ;
21429 int res1 = 0 ;
21430 PyObject *swig_obj[1] ;
21431
21432 if (!args) SWIG_fail;
21433 swig_obj[0] = args;
21434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21435 if (!SWIG_IsOK(res1)) {
21436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21437 }
21438 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21439 result = (bool) ((arg1)->m_leftDown);
21440 {
21441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21442 }
21443 return resultobj;
21444 fail:
21445 return NULL;
21446 }
21447
21448
21449 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21450 PyObject *resultobj = 0;
21451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21452 bool arg2 ;
21453 void *argp1 = 0 ;
21454 int res1 = 0 ;
21455 bool val2 ;
21456 int ecode2 = 0 ;
21457 PyObject *swig_obj[2] ;
21458
21459 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21461 if (!SWIG_IsOK(res1)) {
21462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21463 }
21464 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21465 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21466 if (!SWIG_IsOK(ecode2)) {
21467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21468 }
21469 arg2 = static_cast< bool >(val2);
21470 if (arg1) (arg1)->m_middleDown = arg2;
21471
21472 resultobj = SWIG_Py_Void();
21473 return resultobj;
21474 fail:
21475 return NULL;
21476 }
21477
21478
21479 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21480 PyObject *resultobj = 0;
21481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21482 bool result;
21483 void *argp1 = 0 ;
21484 int res1 = 0 ;
21485 PyObject *swig_obj[1] ;
21486
21487 if (!args) SWIG_fail;
21488 swig_obj[0] = args;
21489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21490 if (!SWIG_IsOK(res1)) {
21491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21492 }
21493 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21494 result = (bool) ((arg1)->m_middleDown);
21495 {
21496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21497 }
21498 return resultobj;
21499 fail:
21500 return NULL;
21501 }
21502
21503
21504 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21505 PyObject *resultobj = 0;
21506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21507 bool arg2 ;
21508 void *argp1 = 0 ;
21509 int res1 = 0 ;
21510 bool val2 ;
21511 int ecode2 = 0 ;
21512 PyObject *swig_obj[2] ;
21513
21514 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21516 if (!SWIG_IsOK(res1)) {
21517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21518 }
21519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21520 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21521 if (!SWIG_IsOK(ecode2)) {
21522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21523 }
21524 arg2 = static_cast< bool >(val2);
21525 if (arg1) (arg1)->m_rightDown = arg2;
21526
21527 resultobj = SWIG_Py_Void();
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21535 PyObject *resultobj = 0;
21536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21537 bool result;
21538 void *argp1 = 0 ;
21539 int res1 = 0 ;
21540 PyObject *swig_obj[1] ;
21541
21542 if (!args) SWIG_fail;
21543 swig_obj[0] = args;
21544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21545 if (!SWIG_IsOK(res1)) {
21546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21547 }
21548 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21549 result = (bool) ((arg1)->m_rightDown);
21550 {
21551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21552 }
21553 return resultobj;
21554 fail:
21555 return NULL;
21556 }
21557
21558
21559 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21560 PyObject *resultobj = 0;
21561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21562 bool arg2 ;
21563 void *argp1 = 0 ;
21564 int res1 = 0 ;
21565 bool val2 ;
21566 int ecode2 = 0 ;
21567 PyObject *swig_obj[2] ;
21568
21569 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21571 if (!SWIG_IsOK(res1)) {
21572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21573 }
21574 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21575 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21576 if (!SWIG_IsOK(ecode2)) {
21577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21578 }
21579 arg2 = static_cast< bool >(val2);
21580 if (arg1) (arg1)->m_controlDown = arg2;
21581
21582 resultobj = SWIG_Py_Void();
21583 return resultobj;
21584 fail:
21585 return NULL;
21586 }
21587
21588
21589 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21590 PyObject *resultobj = 0;
21591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21592 bool result;
21593 void *argp1 = 0 ;
21594 int res1 = 0 ;
21595 PyObject *swig_obj[1] ;
21596
21597 if (!args) SWIG_fail;
21598 swig_obj[0] = args;
21599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21600 if (!SWIG_IsOK(res1)) {
21601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21602 }
21603 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21604 result = (bool) ((arg1)->m_controlDown);
21605 {
21606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21607 }
21608 return resultobj;
21609 fail:
21610 return NULL;
21611 }
21612
21613
21614 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21615 PyObject *resultobj = 0;
21616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21617 bool arg2 ;
21618 void *argp1 = 0 ;
21619 int res1 = 0 ;
21620 bool val2 ;
21621 int ecode2 = 0 ;
21622 PyObject *swig_obj[2] ;
21623
21624 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21626 if (!SWIG_IsOK(res1)) {
21627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21628 }
21629 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21630 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21631 if (!SWIG_IsOK(ecode2)) {
21632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21633 }
21634 arg2 = static_cast< bool >(val2);
21635 if (arg1) (arg1)->m_shiftDown = arg2;
21636
21637 resultobj = SWIG_Py_Void();
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21645 PyObject *resultobj = 0;
21646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21647 bool result;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 PyObject *swig_obj[1] ;
21651
21652 if (!args) SWIG_fail;
21653 swig_obj[0] = args;
21654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21655 if (!SWIG_IsOK(res1)) {
21656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21657 }
21658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21659 result = (bool) ((arg1)->m_shiftDown);
21660 {
21661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21662 }
21663 return resultobj;
21664 fail:
21665 return NULL;
21666 }
21667
21668
21669 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21670 PyObject *resultobj = 0;
21671 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21672 bool arg2 ;
21673 void *argp1 = 0 ;
21674 int res1 = 0 ;
21675 bool val2 ;
21676 int ecode2 = 0 ;
21677 PyObject *swig_obj[2] ;
21678
21679 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21681 if (!SWIG_IsOK(res1)) {
21682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21683 }
21684 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21685 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21686 if (!SWIG_IsOK(ecode2)) {
21687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21688 }
21689 arg2 = static_cast< bool >(val2);
21690 if (arg1) (arg1)->m_altDown = arg2;
21691
21692 resultobj = SWIG_Py_Void();
21693 return resultobj;
21694 fail:
21695 return NULL;
21696 }
21697
21698
21699 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21700 PyObject *resultobj = 0;
21701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21702 bool result;
21703 void *argp1 = 0 ;
21704 int res1 = 0 ;
21705 PyObject *swig_obj[1] ;
21706
21707 if (!args) SWIG_fail;
21708 swig_obj[0] = args;
21709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21710 if (!SWIG_IsOK(res1)) {
21711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21712 }
21713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21714 result = (bool) ((arg1)->m_altDown);
21715 {
21716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21717 }
21718 return resultobj;
21719 fail:
21720 return NULL;
21721 }
21722
21723
21724 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21725 PyObject *resultobj = 0;
21726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21727 bool arg2 ;
21728 void *argp1 = 0 ;
21729 int res1 = 0 ;
21730 bool val2 ;
21731 int ecode2 = 0 ;
21732 PyObject *swig_obj[2] ;
21733
21734 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21736 if (!SWIG_IsOK(res1)) {
21737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21738 }
21739 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21740 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21741 if (!SWIG_IsOK(ecode2)) {
21742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21743 }
21744 arg2 = static_cast< bool >(val2);
21745 if (arg1) (arg1)->m_metaDown = arg2;
21746
21747 resultobj = SWIG_Py_Void();
21748 return resultobj;
21749 fail:
21750 return NULL;
21751 }
21752
21753
21754 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21755 PyObject *resultobj = 0;
21756 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21757 bool result;
21758 void *argp1 = 0 ;
21759 int res1 = 0 ;
21760 PyObject *swig_obj[1] ;
21761
21762 if (!args) SWIG_fail;
21763 swig_obj[0] = args;
21764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21765 if (!SWIG_IsOK(res1)) {
21766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21767 }
21768 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21769 result = (bool) ((arg1)->m_metaDown);
21770 {
21771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21772 }
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21782 int arg2 ;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 int val2 ;
21786 int ecode2 = 0 ;
21787 PyObject *swig_obj[2] ;
21788
21789 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21791 if (!SWIG_IsOK(res1)) {
21792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21793 }
21794 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21795 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21796 if (!SWIG_IsOK(ecode2)) {
21797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21798 }
21799 arg2 = static_cast< int >(val2);
21800 if (arg1) (arg1)->m_wheelRotation = arg2;
21801
21802 resultobj = SWIG_Py_Void();
21803 return resultobj;
21804 fail:
21805 return NULL;
21806 }
21807
21808
21809 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21810 PyObject *resultobj = 0;
21811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21812 int result;
21813 void *argp1 = 0 ;
21814 int res1 = 0 ;
21815 PyObject *swig_obj[1] ;
21816
21817 if (!args) SWIG_fail;
21818 swig_obj[0] = args;
21819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21820 if (!SWIG_IsOK(res1)) {
21821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21822 }
21823 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21824 result = (int) ((arg1)->m_wheelRotation);
21825 resultobj = SWIG_From_int(static_cast< int >(result));
21826 return resultobj;
21827 fail:
21828 return NULL;
21829 }
21830
21831
21832 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21833 PyObject *resultobj = 0;
21834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21835 int arg2 ;
21836 void *argp1 = 0 ;
21837 int res1 = 0 ;
21838 int val2 ;
21839 int ecode2 = 0 ;
21840 PyObject *swig_obj[2] ;
21841
21842 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21844 if (!SWIG_IsOK(res1)) {
21845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21846 }
21847 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21848 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21849 if (!SWIG_IsOK(ecode2)) {
21850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21851 }
21852 arg2 = static_cast< int >(val2);
21853 if (arg1) (arg1)->m_wheelDelta = arg2;
21854
21855 resultobj = SWIG_Py_Void();
21856 return resultobj;
21857 fail:
21858 return NULL;
21859 }
21860
21861
21862 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21863 PyObject *resultobj = 0;
21864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21865 int result;
21866 void *argp1 = 0 ;
21867 int res1 = 0 ;
21868 PyObject *swig_obj[1] ;
21869
21870 if (!args) SWIG_fail;
21871 swig_obj[0] = args;
21872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21873 if (!SWIG_IsOK(res1)) {
21874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21875 }
21876 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21877 result = (int) ((arg1)->m_wheelDelta);
21878 resultobj = SWIG_From_int(static_cast< int >(result));
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21886 PyObject *resultobj = 0;
21887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21888 int arg2 ;
21889 void *argp1 = 0 ;
21890 int res1 = 0 ;
21891 int val2 ;
21892 int ecode2 = 0 ;
21893 PyObject *swig_obj[2] ;
21894
21895 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21897 if (!SWIG_IsOK(res1)) {
21898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21899 }
21900 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21901 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21902 if (!SWIG_IsOK(ecode2)) {
21903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21904 }
21905 arg2 = static_cast< int >(val2);
21906 if (arg1) (arg1)->m_linesPerAction = arg2;
21907
21908 resultobj = SWIG_Py_Void();
21909 return resultobj;
21910 fail:
21911 return NULL;
21912 }
21913
21914
21915 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21916 PyObject *resultobj = 0;
21917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21918 int result;
21919 void *argp1 = 0 ;
21920 int res1 = 0 ;
21921 PyObject *swig_obj[1] ;
21922
21923 if (!args) SWIG_fail;
21924 swig_obj[0] = args;
21925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21926 if (!SWIG_IsOK(res1)) {
21927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21928 }
21929 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21930 result = (int) ((arg1)->m_linesPerAction);
21931 resultobj = SWIG_From_int(static_cast< int >(result));
21932 return resultobj;
21933 fail:
21934 return NULL;
21935 }
21936
21937
21938 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21939 PyObject *obj;
21940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21941 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21942 return SWIG_Py_Void();
21943 }
21944
21945 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21946 return SWIG_Python_InitShadowInstance(args);
21947 }
21948
21949 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21950 PyObject *resultobj = 0;
21951 int arg1 = (int) 0 ;
21952 int arg2 = (int) 0 ;
21953 wxSetCursorEvent *result = 0 ;
21954 int val1 ;
21955 int ecode1 = 0 ;
21956 int val2 ;
21957 int ecode2 = 0 ;
21958 PyObject * obj0 = 0 ;
21959 PyObject * obj1 = 0 ;
21960 char * kwnames[] = {
21961 (char *) "x",(char *) "y", NULL
21962 };
21963
21964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21965 if (obj0) {
21966 ecode1 = SWIG_AsVal_int(obj0, &val1);
21967 if (!SWIG_IsOK(ecode1)) {
21968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21969 }
21970 arg1 = static_cast< int >(val1);
21971 }
21972 if (obj1) {
21973 ecode2 = SWIG_AsVal_int(obj1, &val2);
21974 if (!SWIG_IsOK(ecode2)) {
21975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21976 }
21977 arg2 = static_cast< int >(val2);
21978 }
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21986 return resultobj;
21987 fail:
21988 return NULL;
21989 }
21990
21991
21992 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21993 PyObject *resultobj = 0;
21994 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21995 int result;
21996 void *argp1 = 0 ;
21997 int res1 = 0 ;
21998 PyObject *swig_obj[1] ;
21999
22000 if (!args) SWIG_fail;
22001 swig_obj[0] = args;
22002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22003 if (!SWIG_IsOK(res1)) {
22004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22005 }
22006 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22007 {
22008 PyThreadState* __tstate = wxPyBeginAllowThreads();
22009 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22010 wxPyEndAllowThreads(__tstate);
22011 if (PyErr_Occurred()) SWIG_fail;
22012 }
22013 resultobj = SWIG_From_int(static_cast< int >(result));
22014 return resultobj;
22015 fail:
22016 return NULL;
22017 }
22018
22019
22020 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22021 PyObject *resultobj = 0;
22022 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22023 int result;
22024 void *argp1 = 0 ;
22025 int res1 = 0 ;
22026 PyObject *swig_obj[1] ;
22027
22028 if (!args) SWIG_fail;
22029 swig_obj[0] = args;
22030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22031 if (!SWIG_IsOK(res1)) {
22032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22033 }
22034 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22035 {
22036 PyThreadState* __tstate = wxPyBeginAllowThreads();
22037 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22038 wxPyEndAllowThreads(__tstate);
22039 if (PyErr_Occurred()) SWIG_fail;
22040 }
22041 resultobj = SWIG_From_int(static_cast< int >(result));
22042 return resultobj;
22043 fail:
22044 return NULL;
22045 }
22046
22047
22048 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22049 PyObject *resultobj = 0;
22050 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22051 wxCursor *arg2 = 0 ;
22052 void *argp1 = 0 ;
22053 int res1 = 0 ;
22054 void *argp2 = 0 ;
22055 int res2 = 0 ;
22056 PyObject * obj0 = 0 ;
22057 PyObject * obj1 = 0 ;
22058 char * kwnames[] = {
22059 (char *) "self",(char *) "cursor", NULL
22060 };
22061
22062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22064 if (!SWIG_IsOK(res1)) {
22065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22066 }
22067 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22069 if (!SWIG_IsOK(res2)) {
22070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22071 }
22072 if (!argp2) {
22073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22074 }
22075 arg2 = reinterpret_cast< wxCursor * >(argp2);
22076 {
22077 PyThreadState* __tstate = wxPyBeginAllowThreads();
22078 (arg1)->SetCursor((wxCursor const &)*arg2);
22079 wxPyEndAllowThreads(__tstate);
22080 if (PyErr_Occurred()) SWIG_fail;
22081 }
22082 resultobj = SWIG_Py_Void();
22083 return resultobj;
22084 fail:
22085 return NULL;
22086 }
22087
22088
22089 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22090 PyObject *resultobj = 0;
22091 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22092 wxCursor *result = 0 ;
22093 void *argp1 = 0 ;
22094 int res1 = 0 ;
22095 PyObject *swig_obj[1] ;
22096
22097 if (!args) SWIG_fail;
22098 swig_obj[0] = args;
22099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22100 if (!SWIG_IsOK(res1)) {
22101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22102 }
22103 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 {
22107 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22108 result = (wxCursor *) &_result_ref;
22109 }
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 {
22114 wxCursor* resultptr = new wxCursor(*result);
22115 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22116 }
22117 return resultobj;
22118 fail:
22119 return NULL;
22120 }
22121
22122
22123 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22124 PyObject *resultobj = 0;
22125 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22126 bool result;
22127 void *argp1 = 0 ;
22128 int res1 = 0 ;
22129 PyObject *swig_obj[1] ;
22130
22131 if (!args) SWIG_fail;
22132 swig_obj[0] = args;
22133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22136 }
22137 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22141 wxPyEndAllowThreads(__tstate);
22142 if (PyErr_Occurred()) SWIG_fail;
22143 }
22144 {
22145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22146 }
22147 return resultobj;
22148 fail:
22149 return NULL;
22150 }
22151
22152
22153 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22154 PyObject *obj;
22155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22156 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22157 return SWIG_Py_Void();
22158 }
22159
22160 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22161 return SWIG_Python_InitShadowInstance(args);
22162 }
22163
22164 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22165 PyObject *resultobj = 0;
22166 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22167 wxKeyEvent *result = 0 ;
22168 int val1 ;
22169 int ecode1 = 0 ;
22170 PyObject * obj0 = 0 ;
22171 char * kwnames[] = {
22172 (char *) "eventType", NULL
22173 };
22174
22175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22176 if (obj0) {
22177 ecode1 = SWIG_AsVal_int(obj0, &val1);
22178 if (!SWIG_IsOK(ecode1)) {
22179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22180 }
22181 arg1 = static_cast< wxEventType >(val1);
22182 }
22183 {
22184 PyThreadState* __tstate = wxPyBeginAllowThreads();
22185 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22186 wxPyEndAllowThreads(__tstate);
22187 if (PyErr_Occurred()) SWIG_fail;
22188 }
22189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22190 return resultobj;
22191 fail:
22192 return NULL;
22193 }
22194
22195
22196 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22197 PyObject *resultobj = 0;
22198 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22199 int result;
22200 void *argp1 = 0 ;
22201 int res1 = 0 ;
22202 PyObject *swig_obj[1] ;
22203
22204 if (!args) SWIG_fail;
22205 swig_obj[0] = args;
22206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22207 if (!SWIG_IsOK(res1)) {
22208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22209 }
22210 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 resultobj = SWIG_From_int(static_cast< int >(result));
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22225 PyObject *resultobj = 0;
22226 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22227 bool result;
22228 void *argp1 = 0 ;
22229 int res1 = 0 ;
22230 PyObject *swig_obj[1] ;
22231
22232 if (!args) SWIG_fail;
22233 swig_obj[0] = args;
22234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22235 if (!SWIG_IsOK(res1)) {
22236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22237 }
22238 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 {
22246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22247 }
22248 return resultobj;
22249 fail:
22250 return NULL;
22251 }
22252
22253
22254 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22255 PyObject *resultobj = 0;
22256 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22257 bool result;
22258 void *argp1 = 0 ;
22259 int res1 = 0 ;
22260 PyObject *swig_obj[1] ;
22261
22262 if (!args) SWIG_fail;
22263 swig_obj[0] = args;
22264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22265 if (!SWIG_IsOK(res1)) {
22266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22267 }
22268 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22272 wxPyEndAllowThreads(__tstate);
22273 if (PyErr_Occurred()) SWIG_fail;
22274 }
22275 {
22276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22277 }
22278 return resultobj;
22279 fail:
22280 return NULL;
22281 }
22282
22283
22284 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22285 PyObject *resultobj = 0;
22286 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22287 bool result;
22288 void *argp1 = 0 ;
22289 int res1 = 0 ;
22290 PyObject *swig_obj[1] ;
22291
22292 if (!args) SWIG_fail;
22293 swig_obj[0] = args;
22294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22295 if (!SWIG_IsOK(res1)) {
22296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22297 }
22298 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22299 {
22300 PyThreadState* __tstate = wxPyBeginAllowThreads();
22301 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22302 wxPyEndAllowThreads(__tstate);
22303 if (PyErr_Occurred()) SWIG_fail;
22304 }
22305 {
22306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22307 }
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22315 PyObject *resultobj = 0;
22316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22317 bool result;
22318 void *argp1 = 0 ;
22319 int res1 = 0 ;
22320 PyObject *swig_obj[1] ;
22321
22322 if (!args) SWIG_fail;
22323 swig_obj[0] = args;
22324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22325 if (!SWIG_IsOK(res1)) {
22326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22327 }
22328 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22329 {
22330 PyThreadState* __tstate = wxPyBeginAllowThreads();
22331 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 {
22336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22337 }
22338 return resultobj;
22339 fail:
22340 return NULL;
22341 }
22342
22343
22344 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22345 PyObject *resultobj = 0;
22346 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22347 bool result;
22348 void *argp1 = 0 ;
22349 int res1 = 0 ;
22350 PyObject *swig_obj[1] ;
22351
22352 if (!args) SWIG_fail;
22353 swig_obj[0] = args;
22354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22355 if (!SWIG_IsOK(res1)) {
22356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22357 }
22358 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22359 {
22360 PyThreadState* __tstate = wxPyBeginAllowThreads();
22361 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 {
22366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22367 }
22368 return resultobj;
22369 fail:
22370 return NULL;
22371 }
22372
22373
22374 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22375 PyObject *resultobj = 0;
22376 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22377 bool result;
22378 void *argp1 = 0 ;
22379 int res1 = 0 ;
22380 PyObject *swig_obj[1] ;
22381
22382 if (!args) SWIG_fail;
22383 swig_obj[0] = args;
22384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22385 if (!SWIG_IsOK(res1)) {
22386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22387 }
22388 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 {
22396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22397 }
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22405 PyObject *resultobj = 0;
22406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22407 int result;
22408 void *argp1 = 0 ;
22409 int res1 = 0 ;
22410 PyObject *swig_obj[1] ;
22411
22412 if (!args) SWIG_fail;
22413 swig_obj[0] = args;
22414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22415 if (!SWIG_IsOK(res1)) {
22416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22417 }
22418 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22422 wxPyEndAllowThreads(__tstate);
22423 if (PyErr_Occurred()) SWIG_fail;
22424 }
22425 resultobj = SWIG_From_int(static_cast< int >(result));
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22435 int result;
22436 void *argp1 = 0 ;
22437 int res1 = 0 ;
22438 PyObject *swig_obj[1] ;
22439
22440 if (!args) SWIG_fail;
22441 swig_obj[0] = args;
22442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22443 if (!SWIG_IsOK(res1)) {
22444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22445 }
22446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_From_int(static_cast< int >(result));
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22461 PyObject *resultobj = 0;
22462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22463 int arg2 ;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 int val2 ;
22467 int ecode2 = 0 ;
22468 PyObject * obj0 = 0 ;
22469 PyObject * obj1 = 0 ;
22470 char * kwnames[] = {
22471 (char *) "self",(char *) "uniChar", NULL
22472 };
22473
22474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22476 if (!SWIG_IsOK(res1)) {
22477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22478 }
22479 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22480 ecode2 = SWIG_AsVal_int(obj1, &val2);
22481 if (!SWIG_IsOK(ecode2)) {
22482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22483 }
22484 arg2 = static_cast< int >(val2);
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22488 wxPyEndAllowThreads(__tstate);
22489 if (PyErr_Occurred()) SWIG_fail;
22490 }
22491 resultobj = SWIG_Py_Void();
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22499 PyObject *resultobj = 0;
22500 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22501 unsigned int result;
22502 void *argp1 = 0 ;
22503 int res1 = 0 ;
22504 PyObject *swig_obj[1] ;
22505
22506 if (!args) SWIG_fail;
22507 swig_obj[0] = args;
22508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22509 if (!SWIG_IsOK(res1)) {
22510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22511 }
22512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22513 {
22514 PyThreadState* __tstate = wxPyBeginAllowThreads();
22515 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22516 wxPyEndAllowThreads(__tstate);
22517 if (PyErr_Occurred()) SWIG_fail;
22518 }
22519 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22527 PyObject *resultobj = 0;
22528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22529 unsigned int result;
22530 void *argp1 = 0 ;
22531 int res1 = 0 ;
22532 PyObject *swig_obj[1] ;
22533
22534 if (!args) SWIG_fail;
22535 swig_obj[0] = args;
22536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22537 if (!SWIG_IsOK(res1)) {
22538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22539 }
22540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22541 {
22542 PyThreadState* __tstate = wxPyBeginAllowThreads();
22543 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22544 wxPyEndAllowThreads(__tstate);
22545 if (PyErr_Occurred()) SWIG_fail;
22546 }
22547 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22548 return resultobj;
22549 fail:
22550 return NULL;
22551 }
22552
22553
22554 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22555 PyObject *resultobj = 0;
22556 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22557 wxPoint result;
22558 void *argp1 = 0 ;
22559 int res1 = 0 ;
22560 PyObject *swig_obj[1] ;
22561
22562 if (!args) SWIG_fail;
22563 swig_obj[0] = args;
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_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22567 }
22568 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22569 {
22570 PyThreadState* __tstate = wxPyBeginAllowThreads();
22571 result = (arg1)->GetPosition();
22572 wxPyEndAllowThreads(__tstate);
22573 if (PyErr_Occurred()) SWIG_fail;
22574 }
22575 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22583 PyObject *resultobj = 0;
22584 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22585 long *arg2 = (long *) 0 ;
22586 long *arg3 = (long *) 0 ;
22587 void *argp1 = 0 ;
22588 int res1 = 0 ;
22589 long temp2 ;
22590 int res2 = SWIG_TMPOBJ ;
22591 long temp3 ;
22592 int res3 = SWIG_TMPOBJ ;
22593 PyObject *swig_obj[1] ;
22594
22595 arg2 = &temp2;
22596 arg3 = &temp3;
22597 if (!args) SWIG_fail;
22598 swig_obj[0] = args;
22599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22600 if (!SWIG_IsOK(res1)) {
22601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22602 }
22603 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22604 {
22605 PyThreadState* __tstate = wxPyBeginAllowThreads();
22606 (arg1)->GetPosition(arg2,arg3);
22607 wxPyEndAllowThreads(__tstate);
22608 if (PyErr_Occurred()) SWIG_fail;
22609 }
22610 resultobj = SWIG_Py_Void();
22611 if (SWIG_IsTmpObj(res2)) {
22612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22613 } else {
22614 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22616 }
22617 if (SWIG_IsTmpObj(res3)) {
22618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22619 } else {
22620 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22622 }
22623 return resultobj;
22624 fail:
22625 return NULL;
22626 }
22627
22628
22629 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22630 PyObject *resultobj = 0;
22631 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22632 int result;
22633 void *argp1 = 0 ;
22634 int res1 = 0 ;
22635 PyObject *swig_obj[1] ;
22636
22637 if (!args) SWIG_fail;
22638 swig_obj[0] = args;
22639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22640 if (!SWIG_IsOK(res1)) {
22641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22642 }
22643 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22644 {
22645 PyThreadState* __tstate = wxPyBeginAllowThreads();
22646 result = (int)((wxKeyEvent const *)arg1)->GetX();
22647 wxPyEndAllowThreads(__tstate);
22648 if (PyErr_Occurred()) SWIG_fail;
22649 }
22650 resultobj = SWIG_From_int(static_cast< int >(result));
22651 return resultobj;
22652 fail:
22653 return NULL;
22654 }
22655
22656
22657 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22658 PyObject *resultobj = 0;
22659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22660 int result;
22661 void *argp1 = 0 ;
22662 int res1 = 0 ;
22663 PyObject *swig_obj[1] ;
22664
22665 if (!args) SWIG_fail;
22666 swig_obj[0] = args;
22667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22668 if (!SWIG_IsOK(res1)) {
22669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22670 }
22671 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22672 {
22673 PyThreadState* __tstate = wxPyBeginAllowThreads();
22674 result = (int)((wxKeyEvent const *)arg1)->GetY();
22675 wxPyEndAllowThreads(__tstate);
22676 if (PyErr_Occurred()) SWIG_fail;
22677 }
22678 resultobj = SWIG_From_int(static_cast< int >(result));
22679 return resultobj;
22680 fail:
22681 return NULL;
22682 }
22683
22684
22685 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22686 PyObject *resultobj = 0;
22687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22688 int arg2 ;
22689 void *argp1 = 0 ;
22690 int res1 = 0 ;
22691 int val2 ;
22692 int ecode2 = 0 ;
22693 PyObject *swig_obj[2] ;
22694
22695 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22697 if (!SWIG_IsOK(res1)) {
22698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22699 }
22700 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22701 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22702 if (!SWIG_IsOK(ecode2)) {
22703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22704 }
22705 arg2 = static_cast< int >(val2);
22706 if (arg1) (arg1)->m_x = arg2;
22707
22708 resultobj = SWIG_Py_Void();
22709 return resultobj;
22710 fail:
22711 return NULL;
22712 }
22713
22714
22715 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22716 PyObject *resultobj = 0;
22717 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22718 int result;
22719 void *argp1 = 0 ;
22720 int res1 = 0 ;
22721 PyObject *swig_obj[1] ;
22722
22723 if (!args) SWIG_fail;
22724 swig_obj[0] = args;
22725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22726 if (!SWIG_IsOK(res1)) {
22727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22728 }
22729 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22730 result = (int) ((arg1)->m_x);
22731 resultobj = SWIG_From_int(static_cast< int >(result));
22732 return resultobj;
22733 fail:
22734 return NULL;
22735 }
22736
22737
22738 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22739 PyObject *resultobj = 0;
22740 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22741 int arg2 ;
22742 void *argp1 = 0 ;
22743 int res1 = 0 ;
22744 int val2 ;
22745 int ecode2 = 0 ;
22746 PyObject *swig_obj[2] ;
22747
22748 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22750 if (!SWIG_IsOK(res1)) {
22751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22752 }
22753 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22754 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22755 if (!SWIG_IsOK(ecode2)) {
22756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22757 }
22758 arg2 = static_cast< int >(val2);
22759 if (arg1) (arg1)->m_y = arg2;
22760
22761 resultobj = SWIG_Py_Void();
22762 return resultobj;
22763 fail:
22764 return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *resultobj = 0;
22770 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22771 int result;
22772 void *argp1 = 0 ;
22773 int res1 = 0 ;
22774 PyObject *swig_obj[1] ;
22775
22776 if (!args) SWIG_fail;
22777 swig_obj[0] = args;
22778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22779 if (!SWIG_IsOK(res1)) {
22780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22781 }
22782 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22783 result = (int) ((arg1)->m_y);
22784 resultobj = SWIG_From_int(static_cast< int >(result));
22785 return resultobj;
22786 fail:
22787 return NULL;
22788 }
22789
22790
22791 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22792 PyObject *resultobj = 0;
22793 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22794 long arg2 ;
22795 void *argp1 = 0 ;
22796 int res1 = 0 ;
22797 long val2 ;
22798 int ecode2 = 0 ;
22799 PyObject *swig_obj[2] ;
22800
22801 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22803 if (!SWIG_IsOK(res1)) {
22804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22805 }
22806 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22807 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22808 if (!SWIG_IsOK(ecode2)) {
22809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22810 }
22811 arg2 = static_cast< long >(val2);
22812 if (arg1) (arg1)->m_keyCode = arg2;
22813
22814 resultobj = SWIG_Py_Void();
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22822 PyObject *resultobj = 0;
22823 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22824 long result;
22825 void *argp1 = 0 ;
22826 int res1 = 0 ;
22827 PyObject *swig_obj[1] ;
22828
22829 if (!args) SWIG_fail;
22830 swig_obj[0] = args;
22831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22832 if (!SWIG_IsOK(res1)) {
22833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22834 }
22835 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22836 result = (long) ((arg1)->m_keyCode);
22837 resultobj = SWIG_From_long(static_cast< long >(result));
22838 return resultobj;
22839 fail:
22840 return NULL;
22841 }
22842
22843
22844 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22845 PyObject *resultobj = 0;
22846 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22847 bool arg2 ;
22848 void *argp1 = 0 ;
22849 int res1 = 0 ;
22850 bool val2 ;
22851 int ecode2 = 0 ;
22852 PyObject *swig_obj[2] ;
22853
22854 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22856 if (!SWIG_IsOK(res1)) {
22857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22858 }
22859 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22860 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22861 if (!SWIG_IsOK(ecode2)) {
22862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22863 }
22864 arg2 = static_cast< bool >(val2);
22865 if (arg1) (arg1)->m_controlDown = arg2;
22866
22867 resultobj = SWIG_Py_Void();
22868 return resultobj;
22869 fail:
22870 return NULL;
22871 }
22872
22873
22874 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22875 PyObject *resultobj = 0;
22876 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22877 bool result;
22878 void *argp1 = 0 ;
22879 int res1 = 0 ;
22880 PyObject *swig_obj[1] ;
22881
22882 if (!args) SWIG_fail;
22883 swig_obj[0] = args;
22884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22885 if (!SWIG_IsOK(res1)) {
22886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22887 }
22888 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22889 result = (bool) ((arg1)->m_controlDown);
22890 {
22891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22892 }
22893 return resultobj;
22894 fail:
22895 return NULL;
22896 }
22897
22898
22899 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22900 PyObject *resultobj = 0;
22901 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22902 bool arg2 ;
22903 void *argp1 = 0 ;
22904 int res1 = 0 ;
22905 bool val2 ;
22906 int ecode2 = 0 ;
22907 PyObject *swig_obj[2] ;
22908
22909 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22911 if (!SWIG_IsOK(res1)) {
22912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22913 }
22914 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22915 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22916 if (!SWIG_IsOK(ecode2)) {
22917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22918 }
22919 arg2 = static_cast< bool >(val2);
22920 if (arg1) (arg1)->m_shiftDown = arg2;
22921
22922 resultobj = SWIG_Py_Void();
22923 return resultobj;
22924 fail:
22925 return NULL;
22926 }
22927
22928
22929 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22930 PyObject *resultobj = 0;
22931 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22932 bool result;
22933 void *argp1 = 0 ;
22934 int res1 = 0 ;
22935 PyObject *swig_obj[1] ;
22936
22937 if (!args) SWIG_fail;
22938 swig_obj[0] = args;
22939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22940 if (!SWIG_IsOK(res1)) {
22941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22942 }
22943 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22944 result = (bool) ((arg1)->m_shiftDown);
22945 {
22946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22947 }
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22955 PyObject *resultobj = 0;
22956 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22957 bool arg2 ;
22958 void *argp1 = 0 ;
22959 int res1 = 0 ;
22960 bool val2 ;
22961 int ecode2 = 0 ;
22962 PyObject *swig_obj[2] ;
22963
22964 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22966 if (!SWIG_IsOK(res1)) {
22967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22968 }
22969 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22970 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22971 if (!SWIG_IsOK(ecode2)) {
22972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22973 }
22974 arg2 = static_cast< bool >(val2);
22975 if (arg1) (arg1)->m_altDown = arg2;
22976
22977 resultobj = SWIG_Py_Void();
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22985 PyObject *resultobj = 0;
22986 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22987 bool result;
22988 void *argp1 = 0 ;
22989 int res1 = 0 ;
22990 PyObject *swig_obj[1] ;
22991
22992 if (!args) SWIG_fail;
22993 swig_obj[0] = args;
22994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22995 if (!SWIG_IsOK(res1)) {
22996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22997 }
22998 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22999 result = (bool) ((arg1)->m_altDown);
23000 {
23001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23002 }
23003 return resultobj;
23004 fail:
23005 return NULL;
23006 }
23007
23008
23009 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23010 PyObject *resultobj = 0;
23011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23012 bool arg2 ;
23013 void *argp1 = 0 ;
23014 int res1 = 0 ;
23015 bool val2 ;
23016 int ecode2 = 0 ;
23017 PyObject *swig_obj[2] ;
23018
23019 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23021 if (!SWIG_IsOK(res1)) {
23022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23023 }
23024 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23025 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23026 if (!SWIG_IsOK(ecode2)) {
23027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23028 }
23029 arg2 = static_cast< bool >(val2);
23030 if (arg1) (arg1)->m_metaDown = arg2;
23031
23032 resultobj = SWIG_Py_Void();
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23040 PyObject *resultobj = 0;
23041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23042 bool result;
23043 void *argp1 = 0 ;
23044 int res1 = 0 ;
23045 PyObject *swig_obj[1] ;
23046
23047 if (!args) SWIG_fail;
23048 swig_obj[0] = args;
23049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23050 if (!SWIG_IsOK(res1)) {
23051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23052 }
23053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23054 result = (bool) ((arg1)->m_metaDown);
23055 {
23056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23057 }
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23065 PyObject *resultobj = 0;
23066 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23067 bool arg2 ;
23068 void *argp1 = 0 ;
23069 int res1 = 0 ;
23070 bool val2 ;
23071 int ecode2 = 0 ;
23072 PyObject *swig_obj[2] ;
23073
23074 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23078 }
23079 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23080 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23081 if (!SWIG_IsOK(ecode2)) {
23082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23083 }
23084 arg2 = static_cast< bool >(val2);
23085 if (arg1) (arg1)->m_scanCode = arg2;
23086
23087 resultobj = SWIG_Py_Void();
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23095 PyObject *resultobj = 0;
23096 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23097 bool result;
23098 void *argp1 = 0 ;
23099 int res1 = 0 ;
23100 PyObject *swig_obj[1] ;
23101
23102 if (!args) SWIG_fail;
23103 swig_obj[0] = args;
23104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23107 }
23108 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23109 result = (bool) ((arg1)->m_scanCode);
23110 {
23111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23112 }
23113 return resultobj;
23114 fail:
23115 return NULL;
23116 }
23117
23118
23119 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23120 PyObject *resultobj = 0;
23121 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23122 unsigned int arg2 ;
23123 void *argp1 = 0 ;
23124 int res1 = 0 ;
23125 unsigned int val2 ;
23126 int ecode2 = 0 ;
23127 PyObject *swig_obj[2] ;
23128
23129 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23131 if (!SWIG_IsOK(res1)) {
23132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23133 }
23134 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23135 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23136 if (!SWIG_IsOK(ecode2)) {
23137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23138 }
23139 arg2 = static_cast< unsigned int >(val2);
23140 if (arg1) (arg1)->m_rawCode = arg2;
23141
23142 resultobj = SWIG_Py_Void();
23143 return resultobj;
23144 fail:
23145 return NULL;
23146 }
23147
23148
23149 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23150 PyObject *resultobj = 0;
23151 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23152 unsigned int result;
23153 void *argp1 = 0 ;
23154 int res1 = 0 ;
23155 PyObject *swig_obj[1] ;
23156
23157 if (!args) SWIG_fail;
23158 swig_obj[0] = args;
23159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23160 if (!SWIG_IsOK(res1)) {
23161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23162 }
23163 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23164 result = (unsigned int) ((arg1)->m_rawCode);
23165 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23166 return resultobj;
23167 fail:
23168 return NULL;
23169 }
23170
23171
23172 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23173 PyObject *resultobj = 0;
23174 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23175 unsigned int arg2 ;
23176 void *argp1 = 0 ;
23177 int res1 = 0 ;
23178 unsigned int val2 ;
23179 int ecode2 = 0 ;
23180 PyObject *swig_obj[2] ;
23181
23182 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23184 if (!SWIG_IsOK(res1)) {
23185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23186 }
23187 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23188 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23189 if (!SWIG_IsOK(ecode2)) {
23190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23191 }
23192 arg2 = static_cast< unsigned int >(val2);
23193 if (arg1) (arg1)->m_rawFlags = arg2;
23194
23195 resultobj = SWIG_Py_Void();
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23203 PyObject *resultobj = 0;
23204 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23205 unsigned int result;
23206 void *argp1 = 0 ;
23207 int res1 = 0 ;
23208 PyObject *swig_obj[1] ;
23209
23210 if (!args) SWIG_fail;
23211 swig_obj[0] = args;
23212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23213 if (!SWIG_IsOK(res1)) {
23214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23215 }
23216 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23217 result = (unsigned int) ((arg1)->m_rawFlags);
23218 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23219 return resultobj;
23220 fail:
23221 return NULL;
23222 }
23223
23224
23225 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23226 PyObject *obj;
23227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23228 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23229 return SWIG_Py_Void();
23230 }
23231
23232 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23233 return SWIG_Python_InitShadowInstance(args);
23234 }
23235
23236 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23237 PyObject *resultobj = 0;
23238 wxSize const &arg1_defvalue = wxDefaultSize ;
23239 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23240 int arg2 = (int) 0 ;
23241 wxSizeEvent *result = 0 ;
23242 wxSize temp1 ;
23243 int val2 ;
23244 int ecode2 = 0 ;
23245 PyObject * obj0 = 0 ;
23246 PyObject * obj1 = 0 ;
23247 char * kwnames[] = {
23248 (char *) "sz",(char *) "winid", NULL
23249 };
23250
23251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23252 if (obj0) {
23253 {
23254 arg1 = &temp1;
23255 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23256 }
23257 }
23258 if (obj1) {
23259 ecode2 = SWIG_AsVal_int(obj1, &val2);
23260 if (!SWIG_IsOK(ecode2)) {
23261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23262 }
23263 arg2 = static_cast< int >(val2);
23264 }
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23268 wxPyEndAllowThreads(__tstate);
23269 if (PyErr_Occurred()) SWIG_fail;
23270 }
23271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23272 return resultobj;
23273 fail:
23274 return NULL;
23275 }
23276
23277
23278 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23279 PyObject *resultobj = 0;
23280 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23281 wxSize result;
23282 void *argp1 = 0 ;
23283 int res1 = 0 ;
23284 PyObject *swig_obj[1] ;
23285
23286 if (!args) SWIG_fail;
23287 swig_obj[0] = args;
23288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23289 if (!SWIG_IsOK(res1)) {
23290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23291 }
23292 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23293 {
23294 PyThreadState* __tstate = wxPyBeginAllowThreads();
23295 result = ((wxSizeEvent const *)arg1)->GetSize();
23296 wxPyEndAllowThreads(__tstate);
23297 if (PyErr_Occurred()) SWIG_fail;
23298 }
23299 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23300 return resultobj;
23301 fail:
23302 return NULL;
23303 }
23304
23305
23306 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23307 PyObject *resultobj = 0;
23308 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23309 wxRect result;
23310 void *argp1 = 0 ;
23311 int res1 = 0 ;
23312 PyObject *swig_obj[1] ;
23313
23314 if (!args) SWIG_fail;
23315 swig_obj[0] = args;
23316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23317 if (!SWIG_IsOK(res1)) {
23318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23319 }
23320 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 result = ((wxSizeEvent const *)arg1)->GetRect();
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23328 return resultobj;
23329 fail:
23330 return NULL;
23331 }
23332
23333
23334 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23335 PyObject *resultobj = 0;
23336 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23337 wxRect arg2 ;
23338 void *argp1 = 0 ;
23339 int res1 = 0 ;
23340 void *argp2 ;
23341 int res2 = 0 ;
23342 PyObject * obj0 = 0 ;
23343 PyObject * obj1 = 0 ;
23344 char * kwnames[] = {
23345 (char *) "self",(char *) "rect", NULL
23346 };
23347
23348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23350 if (!SWIG_IsOK(res1)) {
23351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23352 }
23353 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23354 {
23355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23356 if (!SWIG_IsOK(res2)) {
23357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23358 }
23359 if (!argp2) {
23360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23361 } else {
23362 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23363 arg2 = *temp;
23364 if (SWIG_IsNewObj(res2)) delete temp;
23365 }
23366 }
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 (arg1)->SetRect(arg2);
23370 wxPyEndAllowThreads(__tstate);
23371 if (PyErr_Occurred()) SWIG_fail;
23372 }
23373 resultobj = SWIG_Py_Void();
23374 return resultobj;
23375 fail:
23376 return NULL;
23377 }
23378
23379
23380 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23381 PyObject *resultobj = 0;
23382 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23383 wxSize arg2 ;
23384 void *argp1 = 0 ;
23385 int res1 = 0 ;
23386 void *argp2 ;
23387 int res2 = 0 ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char * kwnames[] = {
23391 (char *) "self",(char *) "size", NULL
23392 };
23393
23394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23396 if (!SWIG_IsOK(res1)) {
23397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23398 }
23399 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23400 {
23401 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23402 if (!SWIG_IsOK(res2)) {
23403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23404 }
23405 if (!argp2) {
23406 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23407 } else {
23408 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23409 arg2 = *temp;
23410 if (SWIG_IsNewObj(res2)) delete temp;
23411 }
23412 }
23413 {
23414 PyThreadState* __tstate = wxPyBeginAllowThreads();
23415 wxSizeEvent_SetSize(arg1,arg2);
23416 wxPyEndAllowThreads(__tstate);
23417 if (PyErr_Occurred()) SWIG_fail;
23418 }
23419 resultobj = SWIG_Py_Void();
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23427 PyObject *resultobj = 0;
23428 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23429 wxSize *arg2 = (wxSize *) 0 ;
23430 void *argp1 = 0 ;
23431 int res1 = 0 ;
23432 void *argp2 = 0 ;
23433 int res2 = 0 ;
23434 PyObject *swig_obj[2] ;
23435
23436 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23438 if (!SWIG_IsOK(res1)) {
23439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23440 }
23441 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23442 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23443 if (!SWIG_IsOK(res2)) {
23444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23445 }
23446 arg2 = reinterpret_cast< wxSize * >(argp2);
23447 if (arg1) (arg1)->m_size = *arg2;
23448
23449 resultobj = SWIG_Py_Void();
23450 return resultobj;
23451 fail:
23452 return NULL;
23453 }
23454
23455
23456 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 PyObject *resultobj = 0;
23458 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23459 wxSize *result = 0 ;
23460 void *argp1 = 0 ;
23461 int res1 = 0 ;
23462 PyObject *swig_obj[1] ;
23463
23464 if (!args) SWIG_fail;
23465 swig_obj[0] = args;
23466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23467 if (!SWIG_IsOK(res1)) {
23468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23469 }
23470 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23471 result = (wxSize *)& ((arg1)->m_size);
23472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23473 return resultobj;
23474 fail:
23475 return NULL;
23476 }
23477
23478
23479 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23480 PyObject *resultobj = 0;
23481 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23482 wxRect *arg2 = (wxRect *) 0 ;
23483 void *argp1 = 0 ;
23484 int res1 = 0 ;
23485 void *argp2 = 0 ;
23486 int res2 = 0 ;
23487 PyObject *swig_obj[2] ;
23488
23489 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23491 if (!SWIG_IsOK(res1)) {
23492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23493 }
23494 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23495 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23496 if (!SWIG_IsOK(res2)) {
23497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23498 }
23499 arg2 = reinterpret_cast< wxRect * >(argp2);
23500 if (arg1) (arg1)->m_rect = *arg2;
23501
23502 resultobj = SWIG_Py_Void();
23503 return resultobj;
23504 fail:
23505 return NULL;
23506 }
23507
23508
23509 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23510 PyObject *resultobj = 0;
23511 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23512 wxRect *result = 0 ;
23513 void *argp1 = 0 ;
23514 int res1 = 0 ;
23515 PyObject *swig_obj[1] ;
23516
23517 if (!args) SWIG_fail;
23518 swig_obj[0] = args;
23519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23520 if (!SWIG_IsOK(res1)) {
23521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23522 }
23523 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23524 result = (wxRect *)& ((arg1)->m_rect);
23525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23526 return resultobj;
23527 fail:
23528 return NULL;
23529 }
23530
23531
23532 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23533 PyObject *obj;
23534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23535 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23536 return SWIG_Py_Void();
23537 }
23538
23539 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23540 return SWIG_Python_InitShadowInstance(args);
23541 }
23542
23543 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23544 PyObject *resultobj = 0;
23545 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23546 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23547 int arg2 = (int) 0 ;
23548 wxMoveEvent *result = 0 ;
23549 wxPoint temp1 ;
23550 int val2 ;
23551 int ecode2 = 0 ;
23552 PyObject * obj0 = 0 ;
23553 PyObject * obj1 = 0 ;
23554 char * kwnames[] = {
23555 (char *) "pos",(char *) "winid", NULL
23556 };
23557
23558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23559 if (obj0) {
23560 {
23561 arg1 = &temp1;
23562 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23563 }
23564 }
23565 if (obj1) {
23566 ecode2 = SWIG_AsVal_int(obj1, &val2);
23567 if (!SWIG_IsOK(ecode2)) {
23568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23569 }
23570 arg2 = static_cast< int >(val2);
23571 }
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23579 return resultobj;
23580 fail:
23581 return NULL;
23582 }
23583
23584
23585 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23586 PyObject *resultobj = 0;
23587 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23588 wxPoint result;
23589 void *argp1 = 0 ;
23590 int res1 = 0 ;
23591 PyObject *swig_obj[1] ;
23592
23593 if (!args) SWIG_fail;
23594 swig_obj[0] = args;
23595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23596 if (!SWIG_IsOK(res1)) {
23597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23598 }
23599 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23600 {
23601 PyThreadState* __tstate = wxPyBeginAllowThreads();
23602 result = ((wxMoveEvent const *)arg1)->GetPosition();
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23614 PyObject *resultobj = 0;
23615 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23616 wxRect result;
23617 void *argp1 = 0 ;
23618 int res1 = 0 ;
23619 PyObject *swig_obj[1] ;
23620
23621 if (!args) SWIG_fail;
23622 swig_obj[0] = args;
23623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23624 if (!SWIG_IsOK(res1)) {
23625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23626 }
23627 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = ((wxMoveEvent const *)arg1)->GetRect();
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj = 0;
23643 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23644 wxRect *arg2 = 0 ;
23645 void *argp1 = 0 ;
23646 int res1 = 0 ;
23647 wxRect temp2 ;
23648 PyObject * obj0 = 0 ;
23649 PyObject * obj1 = 0 ;
23650 char * kwnames[] = {
23651 (char *) "self",(char *) "rect", NULL
23652 };
23653
23654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23656 if (!SWIG_IsOK(res1)) {
23657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23658 }
23659 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23660 {
23661 arg2 = &temp2;
23662 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23663 }
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 (arg1)->SetRect((wxRect const &)*arg2);
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 resultobj = SWIG_Py_Void();
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23678 PyObject *resultobj = 0;
23679 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23680 wxPoint *arg2 = 0 ;
23681 void *argp1 = 0 ;
23682 int res1 = 0 ;
23683 wxPoint temp2 ;
23684 PyObject * obj0 = 0 ;
23685 PyObject * obj1 = 0 ;
23686 char * kwnames[] = {
23687 (char *) "self",(char *) "pos", NULL
23688 };
23689
23690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23692 if (!SWIG_IsOK(res1)) {
23693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23694 }
23695 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23696 {
23697 arg2 = &temp2;
23698 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23699 }
23700 {
23701 PyThreadState* __tstate = wxPyBeginAllowThreads();
23702 (arg1)->SetPosition((wxPoint const &)*arg2);
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 resultobj = SWIG_Py_Void();
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23714 PyObject *obj;
23715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23716 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23717 return SWIG_Py_Void();
23718 }
23719
23720 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23721 return SWIG_Python_InitShadowInstance(args);
23722 }
23723
23724 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj = 0;
23726 int arg1 = (int) 0 ;
23727 wxPaintEvent *result = 0 ;
23728 int val1 ;
23729 int ecode1 = 0 ;
23730 PyObject * obj0 = 0 ;
23731 char * kwnames[] = {
23732 (char *) "Id", NULL
23733 };
23734
23735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23736 if (obj0) {
23737 ecode1 = SWIG_AsVal_int(obj0, &val1);
23738 if (!SWIG_IsOK(ecode1)) {
23739 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23740 }
23741 arg1 = static_cast< int >(val1);
23742 }
23743 {
23744 PyThreadState* __tstate = wxPyBeginAllowThreads();
23745 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23746 wxPyEndAllowThreads(__tstate);
23747 if (PyErr_Occurred()) SWIG_fail;
23748 }
23749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23750 return resultobj;
23751 fail:
23752 return NULL;
23753 }
23754
23755
23756 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23757 PyObject *obj;
23758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23759 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23760 return SWIG_Py_Void();
23761 }
23762
23763 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23764 return SWIG_Python_InitShadowInstance(args);
23765 }
23766
23767 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj = 0;
23769 int arg1 = (int) 0 ;
23770 wxNcPaintEvent *result = 0 ;
23771 int val1 ;
23772 int ecode1 = 0 ;
23773 PyObject * obj0 = 0 ;
23774 char * kwnames[] = {
23775 (char *) "winid", NULL
23776 };
23777
23778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23779 if (obj0) {
23780 ecode1 = SWIG_AsVal_int(obj0, &val1);
23781 if (!SWIG_IsOK(ecode1)) {
23782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23783 }
23784 arg1 = static_cast< int >(val1);
23785 }
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800 PyObject *obj;
23801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23802 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23803 return SWIG_Py_Void();
23804 }
23805
23806 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23807 return SWIG_Python_InitShadowInstance(args);
23808 }
23809
23810 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23811 PyObject *resultobj = 0;
23812 int arg1 = (int) 0 ;
23813 wxDC *arg2 = (wxDC *) NULL ;
23814 wxEraseEvent *result = 0 ;
23815 int val1 ;
23816 int ecode1 = 0 ;
23817 void *argp2 = 0 ;
23818 int res2 = 0 ;
23819 PyObject * obj0 = 0 ;
23820 PyObject * obj1 = 0 ;
23821 char * kwnames[] = {
23822 (char *) "Id",(char *) "dc", NULL
23823 };
23824
23825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23826 if (obj0) {
23827 ecode1 = SWIG_AsVal_int(obj0, &val1);
23828 if (!SWIG_IsOK(ecode1)) {
23829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23830 }
23831 arg1 = static_cast< int >(val1);
23832 }
23833 if (obj1) {
23834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23835 if (!SWIG_IsOK(res2)) {
23836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23837 }
23838 arg2 = reinterpret_cast< wxDC * >(argp2);
23839 }
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23854 PyObject *resultobj = 0;
23855 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23856 wxDC *result = 0 ;
23857 void *argp1 = 0 ;
23858 int res1 = 0 ;
23859 PyObject *swig_obj[1] ;
23860
23861 if (!args) SWIG_fail;
23862 swig_obj[0] = args;
23863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23864 if (!SWIG_IsOK(res1)) {
23865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23866 }
23867 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23871 wxPyEndAllowThreads(__tstate);
23872 if (PyErr_Occurred()) SWIG_fail;
23873 }
23874 {
23875 resultobj = wxPyMake_wxObject(result, (bool)0);
23876 }
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *obj;
23885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23886 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23887 return SWIG_Py_Void();
23888 }
23889
23890 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23891 return SWIG_Python_InitShadowInstance(args);
23892 }
23893
23894 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj = 0;
23896 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23897 int arg2 = (int) 0 ;
23898 wxFocusEvent *result = 0 ;
23899 int val1 ;
23900 int ecode1 = 0 ;
23901 int val2 ;
23902 int ecode2 = 0 ;
23903 PyObject * obj0 = 0 ;
23904 PyObject * obj1 = 0 ;
23905 char * kwnames[] = {
23906 (char *) "type",(char *) "winid", NULL
23907 };
23908
23909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23910 if (obj0) {
23911 ecode1 = SWIG_AsVal_int(obj0, &val1);
23912 if (!SWIG_IsOK(ecode1)) {
23913 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23914 }
23915 arg1 = static_cast< wxEventType >(val1);
23916 }
23917 if (obj1) {
23918 ecode2 = SWIG_AsVal_int(obj1, &val2);
23919 if (!SWIG_IsOK(ecode2)) {
23920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23921 }
23922 arg2 = static_cast< int >(val2);
23923 }
23924 {
23925 PyThreadState* __tstate = wxPyBeginAllowThreads();
23926 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23927 wxPyEndAllowThreads(__tstate);
23928 if (PyErr_Occurred()) SWIG_fail;
23929 }
23930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23931 return resultobj;
23932 fail:
23933 return NULL;
23934 }
23935
23936
23937 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23938 PyObject *resultobj = 0;
23939 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23940 wxWindow *result = 0 ;
23941 void *argp1 = 0 ;
23942 int res1 = 0 ;
23943 PyObject *swig_obj[1] ;
23944
23945 if (!args) SWIG_fail;
23946 swig_obj[0] = args;
23947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23948 if (!SWIG_IsOK(res1)) {
23949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23950 }
23951 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23952 {
23953 PyThreadState* __tstate = wxPyBeginAllowThreads();
23954 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23955 wxPyEndAllowThreads(__tstate);
23956 if (PyErr_Occurred()) SWIG_fail;
23957 }
23958 {
23959 resultobj = wxPyMake_wxObject(result, (bool)0);
23960 }
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = 0;
23969 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23970 wxWindow *arg2 = (wxWindow *) 0 ;
23971 void *argp1 = 0 ;
23972 int res1 = 0 ;
23973 void *argp2 = 0 ;
23974 int res2 = 0 ;
23975 PyObject * obj0 = 0 ;
23976 PyObject * obj1 = 0 ;
23977 char * kwnames[] = {
23978 (char *) "self",(char *) "win", NULL
23979 };
23980
23981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23983 if (!SWIG_IsOK(res1)) {
23984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23985 }
23986 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23988 if (!SWIG_IsOK(res2)) {
23989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23990 }
23991 arg2 = reinterpret_cast< wxWindow * >(argp2);
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 (arg1)->SetWindow(arg2);
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 resultobj = SWIG_Py_Void();
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24006 PyObject *obj;
24007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24008 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24009 return SWIG_Py_Void();
24010 }
24011
24012 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24013 return SWIG_Python_InitShadowInstance(args);
24014 }
24015
24016 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24017 PyObject *resultobj = 0;
24018 wxWindow *arg1 = (wxWindow *) NULL ;
24019 wxChildFocusEvent *result = 0 ;
24020 void *argp1 = 0 ;
24021 int res1 = 0 ;
24022 PyObject * obj0 = 0 ;
24023 char * kwnames[] = {
24024 (char *) "win", NULL
24025 };
24026
24027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24028 if (obj0) {
24029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24030 if (!SWIG_IsOK(res1)) {
24031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24032 }
24033 arg1 = reinterpret_cast< wxWindow * >(argp1);
24034 }
24035 {
24036 PyThreadState* __tstate = wxPyBeginAllowThreads();
24037 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24049 PyObject *resultobj = 0;
24050 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24051 wxWindow *result = 0 ;
24052 void *argp1 = 0 ;
24053 int res1 = 0 ;
24054 PyObject *swig_obj[1] ;
24055
24056 if (!args) SWIG_fail;
24057 swig_obj[0] = args;
24058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24059 if (!SWIG_IsOK(res1)) {
24060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24061 }
24062 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24063 {
24064 PyThreadState* __tstate = wxPyBeginAllowThreads();
24065 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 {
24070 resultobj = wxPyMake_wxObject(result, (bool)0);
24071 }
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24079 PyObject *obj;
24080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24081 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24082 return SWIG_Py_Void();
24083 }
24084
24085 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24086 return SWIG_Python_InitShadowInstance(args);
24087 }
24088
24089 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj = 0;
24091 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24092 bool arg2 = (bool) true ;
24093 int arg3 = (int) 0 ;
24094 wxActivateEvent *result = 0 ;
24095 int val1 ;
24096 int ecode1 = 0 ;
24097 bool val2 ;
24098 int ecode2 = 0 ;
24099 int val3 ;
24100 int ecode3 = 0 ;
24101 PyObject * obj0 = 0 ;
24102 PyObject * obj1 = 0 ;
24103 PyObject * obj2 = 0 ;
24104 char * kwnames[] = {
24105 (char *) "type",(char *) "active",(char *) "Id", NULL
24106 };
24107
24108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24109 if (obj0) {
24110 ecode1 = SWIG_AsVal_int(obj0, &val1);
24111 if (!SWIG_IsOK(ecode1)) {
24112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24113 }
24114 arg1 = static_cast< wxEventType >(val1);
24115 }
24116 if (obj1) {
24117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24118 if (!SWIG_IsOK(ecode2)) {
24119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24120 }
24121 arg2 = static_cast< bool >(val2);
24122 }
24123 if (obj2) {
24124 ecode3 = SWIG_AsVal_int(obj2, &val3);
24125 if (!SWIG_IsOK(ecode3)) {
24126 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24127 }
24128 arg3 = static_cast< int >(val3);
24129 }
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24133 wxPyEndAllowThreads(__tstate);
24134 if (PyErr_Occurred()) SWIG_fail;
24135 }
24136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24144 PyObject *resultobj = 0;
24145 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24146 bool result;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 PyObject *swig_obj[1] ;
24150
24151 if (!args) SWIG_fail;
24152 swig_obj[0] = args;
24153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24154 if (!SWIG_IsOK(res1)) {
24155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24156 }
24157 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 {
24165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24166 }
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24174 PyObject *obj;
24175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24176 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24177 return SWIG_Py_Void();
24178 }
24179
24180 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24181 return SWIG_Python_InitShadowInstance(args);
24182 }
24183
24184 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24185 PyObject *resultobj = 0;
24186 int arg1 = (int) 0 ;
24187 wxInitDialogEvent *result = 0 ;
24188 int val1 ;
24189 int ecode1 = 0 ;
24190 PyObject * obj0 = 0 ;
24191 char * kwnames[] = {
24192 (char *) "Id", NULL
24193 };
24194
24195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24196 if (obj0) {
24197 ecode1 = SWIG_AsVal_int(obj0, &val1);
24198 if (!SWIG_IsOK(ecode1)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24200 }
24201 arg1 = static_cast< int >(val1);
24202 }
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24217 PyObject *obj;
24218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24219 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24220 return SWIG_Py_Void();
24221 }
24222
24223 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24224 return SWIG_Python_InitShadowInstance(args);
24225 }
24226
24227 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj = 0;
24229 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24230 int arg2 = (int) 0 ;
24231 wxMenu *arg3 = (wxMenu *) NULL ;
24232 wxMenuEvent *result = 0 ;
24233 int val1 ;
24234 int ecode1 = 0 ;
24235 int val2 ;
24236 int ecode2 = 0 ;
24237 void *argp3 = 0 ;
24238 int res3 = 0 ;
24239 PyObject * obj0 = 0 ;
24240 PyObject * obj1 = 0 ;
24241 PyObject * obj2 = 0 ;
24242 char * kwnames[] = {
24243 (char *) "type",(char *) "winid",(char *) "menu", NULL
24244 };
24245
24246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24247 if (obj0) {
24248 ecode1 = SWIG_AsVal_int(obj0, &val1);
24249 if (!SWIG_IsOK(ecode1)) {
24250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24251 }
24252 arg1 = static_cast< wxEventType >(val1);
24253 }
24254 if (obj1) {
24255 ecode2 = SWIG_AsVal_int(obj1, &val2);
24256 if (!SWIG_IsOK(ecode2)) {
24257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24258 }
24259 arg2 = static_cast< int >(val2);
24260 }
24261 if (obj2) {
24262 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24263 if (!SWIG_IsOK(res3)) {
24264 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24265 }
24266 arg3 = reinterpret_cast< wxMenu * >(argp3);
24267 }
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *resultobj = 0;
24283 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24284 int result;
24285 void *argp1 = 0 ;
24286 int res1 = 0 ;
24287 PyObject *swig_obj[1] ;
24288
24289 if (!args) SWIG_fail;
24290 swig_obj[0] = args;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24294 }
24295 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 resultobj = SWIG_From_int(static_cast< int >(result));
24303 return resultobj;
24304 fail:
24305 return NULL;
24306 }
24307
24308
24309 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24310 PyObject *resultobj = 0;
24311 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24312 bool result;
24313 void *argp1 = 0 ;
24314 int res1 = 0 ;
24315 PyObject *swig_obj[1] ;
24316
24317 if (!args) SWIG_fail;
24318 swig_obj[0] = args;
24319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24320 if (!SWIG_IsOK(res1)) {
24321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24322 }
24323 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 {
24331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24332 }
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24340 PyObject *resultobj = 0;
24341 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24342 wxMenu *result = 0 ;
24343 void *argp1 = 0 ;
24344 int res1 = 0 ;
24345 PyObject *swig_obj[1] ;
24346
24347 if (!args) SWIG_fail;
24348 swig_obj[0] = args;
24349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24350 if (!SWIG_IsOK(res1)) {
24351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24352 }
24353 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 {
24361 resultobj = wxPyMake_wxObject(result, (bool)0);
24362 }
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24370 PyObject *obj;
24371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24372 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24373 return SWIG_Py_Void();
24374 }
24375
24376 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24377 return SWIG_Python_InitShadowInstance(args);
24378 }
24379
24380 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj = 0;
24382 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24383 int arg2 = (int) 0 ;
24384 wxCloseEvent *result = 0 ;
24385 int val1 ;
24386 int ecode1 = 0 ;
24387 int val2 ;
24388 int ecode2 = 0 ;
24389 PyObject * obj0 = 0 ;
24390 PyObject * obj1 = 0 ;
24391 char * kwnames[] = {
24392 (char *) "type",(char *) "winid", NULL
24393 };
24394
24395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24396 if (obj0) {
24397 ecode1 = SWIG_AsVal_int(obj0, &val1);
24398 if (!SWIG_IsOK(ecode1)) {
24399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24400 }
24401 arg1 = static_cast< wxEventType >(val1);
24402 }
24403 if (obj1) {
24404 ecode2 = SWIG_AsVal_int(obj1, &val2);
24405 if (!SWIG_IsOK(ecode2)) {
24406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24407 }
24408 arg2 = static_cast< int >(val2);
24409 }
24410 {
24411 PyThreadState* __tstate = wxPyBeginAllowThreads();
24412 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24424 PyObject *resultobj = 0;
24425 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24426 bool arg2 ;
24427 void *argp1 = 0 ;
24428 int res1 = 0 ;
24429 bool val2 ;
24430 int ecode2 = 0 ;
24431 PyObject * obj0 = 0 ;
24432 PyObject * obj1 = 0 ;
24433 char * kwnames[] = {
24434 (char *) "self",(char *) "logOff", NULL
24435 };
24436
24437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24439 if (!SWIG_IsOK(res1)) {
24440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24441 }
24442 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24443 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24444 if (!SWIG_IsOK(ecode2)) {
24445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24446 }
24447 arg2 = static_cast< bool >(val2);
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 (arg1)->SetLoggingOff(arg2);
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_Py_Void();
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 PyObject *resultobj = 0;
24463 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24464 bool result;
24465 void *argp1 = 0 ;
24466 int res1 = 0 ;
24467 PyObject *swig_obj[1] ;
24468
24469 if (!args) SWIG_fail;
24470 swig_obj[0] = args;
24471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24472 if (!SWIG_IsOK(res1)) {
24473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24474 }
24475 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24476 {
24477 PyThreadState* __tstate = wxPyBeginAllowThreads();
24478 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24492 PyObject *resultobj = 0;
24493 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24494 bool arg2 = (bool) true ;
24495 void *argp1 = 0 ;
24496 int res1 = 0 ;
24497 bool val2 ;
24498 int ecode2 = 0 ;
24499 PyObject * obj0 = 0 ;
24500 PyObject * obj1 = 0 ;
24501 char * kwnames[] = {
24502 (char *) "self",(char *) "veto", NULL
24503 };
24504
24505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24507 if (!SWIG_IsOK(res1)) {
24508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24509 }
24510 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24511 if (obj1) {
24512 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24513 if (!SWIG_IsOK(ecode2)) {
24514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24515 }
24516 arg2 = static_cast< bool >(val2);
24517 }
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 (arg1)->Veto(arg2);
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = SWIG_Py_Void();
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *resultobj = 0;
24533 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24534 bool result;
24535 void *argp1 = 0 ;
24536 int res1 = 0 ;
24537 PyObject *swig_obj[1] ;
24538
24539 if (!args) SWIG_fail;
24540 swig_obj[0] = args;
24541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24542 if (!SWIG_IsOK(res1)) {
24543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24544 }
24545 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24549 wxPyEndAllowThreads(__tstate);
24550 if (PyErr_Occurred()) SWIG_fail;
24551 }
24552 {
24553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24554 }
24555 return resultobj;
24556 fail:
24557 return NULL;
24558 }
24559
24560
24561 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24562 PyObject *resultobj = 0;
24563 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24564 bool arg2 ;
24565 void *argp1 = 0 ;
24566 int res1 = 0 ;
24567 bool val2 ;
24568 int ecode2 = 0 ;
24569 PyObject * obj0 = 0 ;
24570 PyObject * obj1 = 0 ;
24571 char * kwnames[] = {
24572 (char *) "self",(char *) "canVeto", NULL
24573 };
24574
24575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24577 if (!SWIG_IsOK(res1)) {
24578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24579 }
24580 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24581 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24582 if (!SWIG_IsOK(ecode2)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24584 }
24585 arg2 = static_cast< bool >(val2);
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 (arg1)->SetCanVeto(arg2);
24589 wxPyEndAllowThreads(__tstate);
24590 if (PyErr_Occurred()) SWIG_fail;
24591 }
24592 resultobj = SWIG_Py_Void();
24593 return resultobj;
24594 fail:
24595 return NULL;
24596 }
24597
24598
24599 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 PyObject *resultobj = 0;
24601 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24602 bool result;
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_wxCloseEvent, 0 | 0 );
24610 if (!SWIG_IsOK(res1)) {
24611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24612 }
24613 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24617 wxPyEndAllowThreads(__tstate);
24618 if (PyErr_Occurred()) SWIG_fail;
24619 }
24620 {
24621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24622 }
24623 return resultobj;
24624 fail:
24625 return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 PyObject *obj;
24631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24632 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24633 return SWIG_Py_Void();
24634 }
24635
24636 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24637 return SWIG_Python_InitShadowInstance(args);
24638 }
24639
24640 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj = 0;
24642 int arg1 = (int) 0 ;
24643 bool arg2 = (bool) false ;
24644 wxShowEvent *result = 0 ;
24645 int val1 ;
24646 int ecode1 = 0 ;
24647 bool val2 ;
24648 int ecode2 = 0 ;
24649 PyObject * obj0 = 0 ;
24650 PyObject * obj1 = 0 ;
24651 char * kwnames[] = {
24652 (char *) "winid",(char *) "show", NULL
24653 };
24654
24655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24656 if (obj0) {
24657 ecode1 = SWIG_AsVal_int(obj0, &val1);
24658 if (!SWIG_IsOK(ecode1)) {
24659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24660 }
24661 arg1 = static_cast< int >(val1);
24662 }
24663 if (obj1) {
24664 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24665 if (!SWIG_IsOK(ecode2)) {
24666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24667 }
24668 arg2 = static_cast< bool >(val2);
24669 }
24670 {
24671 PyThreadState* __tstate = wxPyBeginAllowThreads();
24672 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24673 wxPyEndAllowThreads(__tstate);
24674 if (PyErr_Occurred()) SWIG_fail;
24675 }
24676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj = 0;
24685 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24686 bool arg2 ;
24687 void *argp1 = 0 ;
24688 int res1 = 0 ;
24689 bool val2 ;
24690 int ecode2 = 0 ;
24691 PyObject * obj0 = 0 ;
24692 PyObject * obj1 = 0 ;
24693 char * kwnames[] = {
24694 (char *) "self",(char *) "show", NULL
24695 };
24696
24697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24699 if (!SWIG_IsOK(res1)) {
24700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24701 }
24702 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24704 if (!SWIG_IsOK(ecode2)) {
24705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24706 }
24707 arg2 = static_cast< bool >(val2);
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 (arg1)->SetShow(arg2);
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 resultobj = SWIG_Py_Void();
24715 return resultobj;
24716 fail:
24717 return NULL;
24718 }
24719
24720
24721 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24722 PyObject *resultobj = 0;
24723 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24724 bool result;
24725 void *argp1 = 0 ;
24726 int res1 = 0 ;
24727 PyObject *swig_obj[1] ;
24728
24729 if (!args) SWIG_fail;
24730 swig_obj[0] = args;
24731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24732 if (!SWIG_IsOK(res1)) {
24733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24734 }
24735 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 {
24743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24744 }
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24752 PyObject *obj;
24753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24754 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24755 return SWIG_Py_Void();
24756 }
24757
24758 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24759 return SWIG_Python_InitShadowInstance(args);
24760 }
24761
24762 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24763 PyObject *resultobj = 0;
24764 int arg1 = (int) 0 ;
24765 bool arg2 = (bool) true ;
24766 wxIconizeEvent *result = 0 ;
24767 int val1 ;
24768 int ecode1 = 0 ;
24769 bool val2 ;
24770 int ecode2 = 0 ;
24771 PyObject * obj0 = 0 ;
24772 PyObject * obj1 = 0 ;
24773 char * kwnames[] = {
24774 (char *) "id",(char *) "iconized", NULL
24775 };
24776
24777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24778 if (obj0) {
24779 ecode1 = SWIG_AsVal_int(obj0, &val1);
24780 if (!SWIG_IsOK(ecode1)) {
24781 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24782 }
24783 arg1 = static_cast< int >(val1);
24784 }
24785 if (obj1) {
24786 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24787 if (!SWIG_IsOK(ecode2)) {
24788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24789 }
24790 arg2 = static_cast< bool >(val2);
24791 }
24792 {
24793 PyThreadState* __tstate = wxPyBeginAllowThreads();
24794 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24799 return resultobj;
24800 fail:
24801 return NULL;
24802 }
24803
24804
24805 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24806 PyObject *resultobj = 0;
24807 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24808 bool result;
24809 void *argp1 = 0 ;
24810 int res1 = 0 ;
24811 PyObject *swig_obj[1] ;
24812
24813 if (!args) SWIG_fail;
24814 swig_obj[0] = args;
24815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24816 if (!SWIG_IsOK(res1)) {
24817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24818 }
24819 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 result = (bool)(arg1)->Iconized();
24823 wxPyEndAllowThreads(__tstate);
24824 if (PyErr_Occurred()) SWIG_fail;
24825 }
24826 {
24827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24828 }
24829 return resultobj;
24830 fail:
24831 return NULL;
24832 }
24833
24834
24835 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24836 PyObject *obj;
24837 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24838 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24839 return SWIG_Py_Void();
24840 }
24841
24842 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24843 return SWIG_Python_InitShadowInstance(args);
24844 }
24845
24846 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24847 PyObject *resultobj = 0;
24848 int arg1 = (int) 0 ;
24849 wxMaximizeEvent *result = 0 ;
24850 int val1 ;
24851 int ecode1 = 0 ;
24852 PyObject * obj0 = 0 ;
24853 char * kwnames[] = {
24854 (char *) "id", NULL
24855 };
24856
24857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24858 if (obj0) {
24859 ecode1 = SWIG_AsVal_int(obj0, &val1);
24860 if (!SWIG_IsOK(ecode1)) {
24861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24862 }
24863 arg1 = static_cast< int >(val1);
24864 }
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24879 PyObject *obj;
24880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24881 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24882 return SWIG_Py_Void();
24883 }
24884
24885 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24886 return SWIG_Python_InitShadowInstance(args);
24887 }
24888
24889 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890 PyObject *resultobj = 0;
24891 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24892 wxPoint result;
24893 void *argp1 = 0 ;
24894 int res1 = 0 ;
24895 PyObject *swig_obj[1] ;
24896
24897 if (!args) SWIG_fail;
24898 swig_obj[0] = args;
24899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24900 if (!SWIG_IsOK(res1)) {
24901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24902 }
24903 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (arg1)->GetPosition();
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24918 PyObject *resultobj = 0;
24919 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24920 int result;
24921 void *argp1 = 0 ;
24922 int res1 = 0 ;
24923 PyObject *swig_obj[1] ;
24924
24925 if (!args) SWIG_fail;
24926 swig_obj[0] = args;
24927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24930 }
24931 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (int)(arg1)->GetNumberOfFiles();
24935 wxPyEndAllowThreads(__tstate);
24936 if (PyErr_Occurred()) SWIG_fail;
24937 }
24938 resultobj = SWIG_From_int(static_cast< int >(result));
24939 return resultobj;
24940 fail:
24941 return NULL;
24942 }
24943
24944
24945 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24946 PyObject *resultobj = 0;
24947 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24948 PyObject *result = 0 ;
24949 void *argp1 = 0 ;
24950 int res1 = 0 ;
24951 PyObject *swig_obj[1] ;
24952
24953 if (!args) SWIG_fail;
24954 swig_obj[0] = args;
24955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24956 if (!SWIG_IsOK(res1)) {
24957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24958 }
24959 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24960 {
24961 PyThreadState* __tstate = wxPyBeginAllowThreads();
24962 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24963 wxPyEndAllowThreads(__tstate);
24964 if (PyErr_Occurred()) SWIG_fail;
24965 }
24966 resultobj = result;
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24974 PyObject *obj;
24975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24976 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24977 return SWIG_Py_Void();
24978 }
24979
24980 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24981 PyObject *resultobj = 0;
24982 int arg1 = (int) 0 ;
24983 wxUpdateUIEvent *result = 0 ;
24984 int val1 ;
24985 int ecode1 = 0 ;
24986 PyObject * obj0 = 0 ;
24987 char * kwnames[] = {
24988 (char *) "commandId", NULL
24989 };
24990
24991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24992 if (obj0) {
24993 ecode1 = SWIG_AsVal_int(obj0, &val1);
24994 if (!SWIG_IsOK(ecode1)) {
24995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24996 }
24997 arg1 = static_cast< int >(val1);
24998 }
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25002 wxPyEndAllowThreads(__tstate);
25003 if (PyErr_Occurred()) SWIG_fail;
25004 }
25005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25006 return resultobj;
25007 fail:
25008 return NULL;
25009 }
25010
25011
25012 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25013 PyObject *resultobj = 0;
25014 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25015 bool result;
25016 void *argp1 = 0 ;
25017 int res1 = 0 ;
25018 PyObject *swig_obj[1] ;
25019
25020 if (!args) SWIG_fail;
25021 swig_obj[0] = args;
25022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25023 if (!SWIG_IsOK(res1)) {
25024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25025 }
25026 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 {
25034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25035 }
25036 return resultobj;
25037 fail:
25038 return NULL;
25039 }
25040
25041
25042 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25043 PyObject *resultobj = 0;
25044 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25045 bool result;
25046 void *argp1 = 0 ;
25047 int res1 = 0 ;
25048 PyObject *swig_obj[1] ;
25049
25050 if (!args) SWIG_fail;
25051 swig_obj[0] = args;
25052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25053 if (!SWIG_IsOK(res1)) {
25054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25055 }
25056 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25057 {
25058 PyThreadState* __tstate = wxPyBeginAllowThreads();
25059 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25060 wxPyEndAllowThreads(__tstate);
25061 if (PyErr_Occurred()) SWIG_fail;
25062 }
25063 {
25064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25065 }
25066 return resultobj;
25067 fail:
25068 return NULL;
25069 }
25070
25071
25072 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25073 PyObject *resultobj = 0;
25074 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25075 bool result;
25076 void *argp1 = 0 ;
25077 int res1 = 0 ;
25078 PyObject *swig_obj[1] ;
25079
25080 if (!args) SWIG_fail;
25081 swig_obj[0] = args;
25082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25083 if (!SWIG_IsOK(res1)) {
25084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25085 }
25086 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 {
25094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25095 }
25096 return resultobj;
25097 fail:
25098 return NULL;
25099 }
25100
25101
25102 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25103 PyObject *resultobj = 0;
25104 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25105 wxString result;
25106 void *argp1 = 0 ;
25107 int res1 = 0 ;
25108 PyObject *swig_obj[1] ;
25109
25110 if (!args) SWIG_fail;
25111 swig_obj[0] = args;
25112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25115 }
25116 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 {
25124 #if wxUSE_UNICODE
25125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25126 #else
25127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25128 #endif
25129 }
25130 return resultobj;
25131 fail:
25132 return NULL;
25133 }
25134
25135
25136 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25137 PyObject *resultobj = 0;
25138 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25139 bool result;
25140 void *argp1 = 0 ;
25141 int res1 = 0 ;
25142 PyObject *swig_obj[1] ;
25143
25144 if (!args) SWIG_fail;
25145 swig_obj[0] = args;
25146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25147 if (!SWIG_IsOK(res1)) {
25148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25149 }
25150 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 {
25158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25159 }
25160 return resultobj;
25161 fail:
25162 return NULL;
25163 }
25164
25165
25166 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25167 PyObject *resultobj = 0;
25168 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25169 bool result;
25170 void *argp1 = 0 ;
25171 int res1 = 0 ;
25172 PyObject *swig_obj[1] ;
25173
25174 if (!args) SWIG_fail;
25175 swig_obj[0] = args;
25176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25177 if (!SWIG_IsOK(res1)) {
25178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25179 }
25180 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 {
25188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25189 }
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25197 PyObject *resultobj = 0;
25198 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25199 bool result;
25200 void *argp1 = 0 ;
25201 int res1 = 0 ;
25202 PyObject *swig_obj[1] ;
25203
25204 if (!args) SWIG_fail;
25205 swig_obj[0] = args;
25206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25207 if (!SWIG_IsOK(res1)) {
25208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25209 }
25210 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25219 }
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25227 PyObject *resultobj = 0;
25228 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25229 bool result;
25230 void *argp1 = 0 ;
25231 int res1 = 0 ;
25232 PyObject *swig_obj[1] ;
25233
25234 if (!args) SWIG_fail;
25235 swig_obj[0] = args;
25236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25237 if (!SWIG_IsOK(res1)) {
25238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25239 }
25240 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25244 wxPyEndAllowThreads(__tstate);
25245 if (PyErr_Occurred()) SWIG_fail;
25246 }
25247 {
25248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25249 }
25250 return resultobj;
25251 fail:
25252 return NULL;
25253 }
25254
25255
25256 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25257 PyObject *resultobj = 0;
25258 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25259 bool arg2 ;
25260 void *argp1 = 0 ;
25261 int res1 = 0 ;
25262 bool val2 ;
25263 int ecode2 = 0 ;
25264 PyObject * obj0 = 0 ;
25265 PyObject * obj1 = 0 ;
25266 char * kwnames[] = {
25267 (char *) "self",(char *) "check", NULL
25268 };
25269
25270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25272 if (!SWIG_IsOK(res1)) {
25273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25274 }
25275 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25276 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25277 if (!SWIG_IsOK(ecode2)) {
25278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25279 }
25280 arg2 = static_cast< bool >(val2);
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 (arg1)->Check(arg2);
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_Py_Void();
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25295 PyObject *resultobj = 0;
25296 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25297 bool arg2 ;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 bool val2 ;
25301 int ecode2 = 0 ;
25302 PyObject * obj0 = 0 ;
25303 PyObject * obj1 = 0 ;
25304 char * kwnames[] = {
25305 (char *) "self",(char *) "enable", NULL
25306 };
25307
25308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25310 if (!SWIG_IsOK(res1)) {
25311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25312 }
25313 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25315 if (!SWIG_IsOK(ecode2)) {
25316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25317 }
25318 arg2 = static_cast< bool >(val2);
25319 {
25320 PyThreadState* __tstate = wxPyBeginAllowThreads();
25321 (arg1)->Enable(arg2);
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 resultobj = SWIG_Py_Void();
25326 return resultobj;
25327 fail:
25328 return NULL;
25329 }
25330
25331
25332 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25333 PyObject *resultobj = 0;
25334 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25335 bool arg2 ;
25336 void *argp1 = 0 ;
25337 int res1 = 0 ;
25338 bool val2 ;
25339 int ecode2 = 0 ;
25340 PyObject * obj0 = 0 ;
25341 PyObject * obj1 = 0 ;
25342 char * kwnames[] = {
25343 (char *) "self",(char *) "show", NULL
25344 };
25345
25346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25348 if (!SWIG_IsOK(res1)) {
25349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25350 }
25351 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25352 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25353 if (!SWIG_IsOK(ecode2)) {
25354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25355 }
25356 arg2 = static_cast< bool >(val2);
25357 {
25358 PyThreadState* __tstate = wxPyBeginAllowThreads();
25359 (arg1)->Show(arg2);
25360 wxPyEndAllowThreads(__tstate);
25361 if (PyErr_Occurred()) SWIG_fail;
25362 }
25363 resultobj = SWIG_Py_Void();
25364 return resultobj;
25365 fail:
25366 return NULL;
25367 }
25368
25369
25370 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25371 PyObject *resultobj = 0;
25372 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25373 wxString *arg2 = 0 ;
25374 void *argp1 = 0 ;
25375 int res1 = 0 ;
25376 bool temp2 = false ;
25377 PyObject * obj0 = 0 ;
25378 PyObject * obj1 = 0 ;
25379 char * kwnames[] = {
25380 (char *) "self",(char *) "text", NULL
25381 };
25382
25383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25385 if (!SWIG_IsOK(res1)) {
25386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25387 }
25388 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25389 {
25390 arg2 = wxString_in_helper(obj1);
25391 if (arg2 == NULL) SWIG_fail;
25392 temp2 = true;
25393 }
25394 {
25395 PyThreadState* __tstate = wxPyBeginAllowThreads();
25396 (arg1)->SetText((wxString const &)*arg2);
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 resultobj = SWIG_Py_Void();
25401 {
25402 if (temp2)
25403 delete arg2;
25404 }
25405 return resultobj;
25406 fail:
25407 {
25408 if (temp2)
25409 delete arg2;
25410 }
25411 return NULL;
25412 }
25413
25414
25415 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25416 PyObject *resultobj = 0;
25417 long arg1 ;
25418 long val1 ;
25419 int ecode1 = 0 ;
25420 PyObject * obj0 = 0 ;
25421 char * kwnames[] = {
25422 (char *) "updateInterval", NULL
25423 };
25424
25425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25426 ecode1 = SWIG_AsVal_long(obj0, &val1);
25427 if (!SWIG_IsOK(ecode1)) {
25428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25429 }
25430 arg1 = static_cast< long >(val1);
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 wxUpdateUIEvent::SetUpdateInterval(arg1);
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 resultobj = SWIG_Py_Void();
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445 PyObject *resultobj = 0;
25446 long result;
25447
25448 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25452 wxPyEndAllowThreads(__tstate);
25453 if (PyErr_Occurred()) SWIG_fail;
25454 }
25455 resultobj = SWIG_From_long(static_cast< long >(result));
25456 return resultobj;
25457 fail:
25458 return NULL;
25459 }
25460
25461
25462 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25463 PyObject *resultobj = 0;
25464 wxWindow *arg1 = (wxWindow *) 0 ;
25465 bool result;
25466 void *argp1 = 0 ;
25467 int res1 = 0 ;
25468 PyObject * obj0 = 0 ;
25469 char * kwnames[] = {
25470 (char *) "win", NULL
25471 };
25472
25473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25475 if (!SWIG_IsOK(res1)) {
25476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25477 }
25478 arg1 = reinterpret_cast< wxWindow * >(argp1);
25479 {
25480 PyThreadState* __tstate = wxPyBeginAllowThreads();
25481 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25482 wxPyEndAllowThreads(__tstate);
25483 if (PyErr_Occurred()) SWIG_fail;
25484 }
25485 {
25486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25487 }
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496
25497 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 wxUpdateUIEvent::ResetUpdateTime();
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 resultobj = SWIG_Py_Void();
25505 return resultobj;
25506 fail:
25507 return NULL;
25508 }
25509
25510
25511 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25512 PyObject *resultobj = 0;
25513 wxUpdateUIMode arg1 ;
25514 int val1 ;
25515 int ecode1 = 0 ;
25516 PyObject * obj0 = 0 ;
25517 char * kwnames[] = {
25518 (char *) "mode", NULL
25519 };
25520
25521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25522 ecode1 = SWIG_AsVal_int(obj0, &val1);
25523 if (!SWIG_IsOK(ecode1)) {
25524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25525 }
25526 arg1 = static_cast< wxUpdateUIMode >(val1);
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 wxUpdateUIEvent::SetMode(arg1);
25530 wxPyEndAllowThreads(__tstate);
25531 if (PyErr_Occurred()) SWIG_fail;
25532 }
25533 resultobj = SWIG_Py_Void();
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxUpdateUIMode result;
25543
25544 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25545 {
25546 PyThreadState* __tstate = wxPyBeginAllowThreads();
25547 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25548 wxPyEndAllowThreads(__tstate);
25549 if (PyErr_Occurred()) SWIG_fail;
25550 }
25551 resultobj = SWIG_From_int(static_cast< int >(result));
25552 return resultobj;
25553 fail:
25554 return NULL;
25555 }
25556
25557
25558 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25559 PyObject *obj;
25560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25561 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25562 return SWIG_Py_Void();
25563 }
25564
25565 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25566 return SWIG_Python_InitShadowInstance(args);
25567 }
25568
25569 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25570 PyObject *resultobj = 0;
25571 wxSysColourChangedEvent *result = 0 ;
25572
25573 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25588 PyObject *obj;
25589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25590 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25591 return SWIG_Py_Void();
25592 }
25593
25594 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25595 return SWIG_Python_InitShadowInstance(args);
25596 }
25597
25598 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25599 PyObject *resultobj = 0;
25600 int arg1 = (int) 0 ;
25601 wxWindow *arg2 = (wxWindow *) NULL ;
25602 wxMouseCaptureChangedEvent *result = 0 ;
25603 int val1 ;
25604 int ecode1 = 0 ;
25605 void *argp2 = 0 ;
25606 int res2 = 0 ;
25607 PyObject * obj0 = 0 ;
25608 PyObject * obj1 = 0 ;
25609 char * kwnames[] = {
25610 (char *) "winid",(char *) "gainedCapture", NULL
25611 };
25612
25613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25614 if (obj0) {
25615 ecode1 = SWIG_AsVal_int(obj0, &val1);
25616 if (!SWIG_IsOK(ecode1)) {
25617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25618 }
25619 arg1 = static_cast< int >(val1);
25620 }
25621 if (obj1) {
25622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25623 if (!SWIG_IsOK(res2)) {
25624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25625 }
25626 arg2 = reinterpret_cast< wxWindow * >(argp2);
25627 }
25628 {
25629 PyThreadState* __tstate = wxPyBeginAllowThreads();
25630 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25635 return resultobj;
25636 fail:
25637 return NULL;
25638 }
25639
25640
25641 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25642 PyObject *resultobj = 0;
25643 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25644 wxWindow *result = 0 ;
25645 void *argp1 = 0 ;
25646 int res1 = 0 ;
25647 PyObject *swig_obj[1] ;
25648
25649 if (!args) SWIG_fail;
25650 swig_obj[0] = args;
25651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25652 if (!SWIG_IsOK(res1)) {
25653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25654 }
25655 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25656 {
25657 PyThreadState* __tstate = wxPyBeginAllowThreads();
25658 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25659 wxPyEndAllowThreads(__tstate);
25660 if (PyErr_Occurred()) SWIG_fail;
25661 }
25662 {
25663 resultobj = wxPyMake_wxObject(result, (bool)0);
25664 }
25665 return resultobj;
25666 fail:
25667 return NULL;
25668 }
25669
25670
25671 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25672 PyObject *obj;
25673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25674 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25675 return SWIG_Py_Void();
25676 }
25677
25678 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25679 return SWIG_Python_InitShadowInstance(args);
25680 }
25681
25682 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25683 PyObject *resultobj = 0;
25684 int arg1 = (int) 0 ;
25685 wxMouseCaptureLostEvent *result = 0 ;
25686 int val1 ;
25687 int ecode1 = 0 ;
25688 PyObject * obj0 = 0 ;
25689 char * kwnames[] = {
25690 (char *) "winid", NULL
25691 };
25692
25693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25694 if (obj0) {
25695 ecode1 = SWIG_AsVal_int(obj0, &val1);
25696 if (!SWIG_IsOK(ecode1)) {
25697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25698 }
25699 arg1 = static_cast< int >(val1);
25700 }
25701 {
25702 PyThreadState* __tstate = wxPyBeginAllowThreads();
25703 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25704 wxPyEndAllowThreads(__tstate);
25705 if (PyErr_Occurred()) SWIG_fail;
25706 }
25707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25708 return resultobj;
25709 fail:
25710 return NULL;
25711 }
25712
25713
25714 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25715 PyObject *obj;
25716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25717 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25718 return SWIG_Py_Void();
25719 }
25720
25721 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25722 return SWIG_Python_InitShadowInstance(args);
25723 }
25724
25725 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25726 PyObject *resultobj = 0;
25727 wxDisplayChangedEvent *result = 0 ;
25728
25729 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25733 wxPyEndAllowThreads(__tstate);
25734 if (PyErr_Occurred()) SWIG_fail;
25735 }
25736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25737 return resultobj;
25738 fail:
25739 return NULL;
25740 }
25741
25742
25743 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25744 PyObject *obj;
25745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25746 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25747 return SWIG_Py_Void();
25748 }
25749
25750 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25751 return SWIG_Python_InitShadowInstance(args);
25752 }
25753
25754 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25755 PyObject *resultobj = 0;
25756 int arg1 = (int) 0 ;
25757 wxPaletteChangedEvent *result = 0 ;
25758 int val1 ;
25759 int ecode1 = 0 ;
25760 PyObject * obj0 = 0 ;
25761 char * kwnames[] = {
25762 (char *) "id", NULL
25763 };
25764
25765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25766 if (obj0) {
25767 ecode1 = SWIG_AsVal_int(obj0, &val1);
25768 if (!SWIG_IsOK(ecode1)) {
25769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25770 }
25771 arg1 = static_cast< int >(val1);
25772 }
25773 {
25774 PyThreadState* __tstate = wxPyBeginAllowThreads();
25775 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25776 wxPyEndAllowThreads(__tstate);
25777 if (PyErr_Occurred()) SWIG_fail;
25778 }
25779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25780 return resultobj;
25781 fail:
25782 return NULL;
25783 }
25784
25785
25786 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25787 PyObject *resultobj = 0;
25788 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25789 wxWindow *arg2 = (wxWindow *) 0 ;
25790 void *argp1 = 0 ;
25791 int res1 = 0 ;
25792 void *argp2 = 0 ;
25793 int res2 = 0 ;
25794 PyObject * obj0 = 0 ;
25795 PyObject * obj1 = 0 ;
25796 char * kwnames[] = {
25797 (char *) "self",(char *) "win", NULL
25798 };
25799
25800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25802 if (!SWIG_IsOK(res1)) {
25803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25804 }
25805 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25806 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25807 if (!SWIG_IsOK(res2)) {
25808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25809 }
25810 arg2 = reinterpret_cast< wxWindow * >(argp2);
25811 {
25812 PyThreadState* __tstate = wxPyBeginAllowThreads();
25813 (arg1)->SetChangedWindow(arg2);
25814 wxPyEndAllowThreads(__tstate);
25815 if (PyErr_Occurred()) SWIG_fail;
25816 }
25817 resultobj = SWIG_Py_Void();
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25825 PyObject *resultobj = 0;
25826 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25827 wxWindow *result = 0 ;
25828 void *argp1 = 0 ;
25829 int res1 = 0 ;
25830 PyObject *swig_obj[1] ;
25831
25832 if (!args) SWIG_fail;
25833 swig_obj[0] = args;
25834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25835 if (!SWIG_IsOK(res1)) {
25836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25837 }
25838 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25839 {
25840 PyThreadState* __tstate = wxPyBeginAllowThreads();
25841 result = (wxWindow *)(arg1)->GetChangedWindow();
25842 wxPyEndAllowThreads(__tstate);
25843 if (PyErr_Occurred()) SWIG_fail;
25844 }
25845 {
25846 resultobj = wxPyMake_wxObject(result, (bool)0);
25847 }
25848 return resultobj;
25849 fail:
25850 return NULL;
25851 }
25852
25853
25854 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25855 PyObject *obj;
25856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25857 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25858 return SWIG_Py_Void();
25859 }
25860
25861 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25862 return SWIG_Python_InitShadowInstance(args);
25863 }
25864
25865 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj = 0;
25867 int arg1 = (int) 0 ;
25868 wxQueryNewPaletteEvent *result = 0 ;
25869 int val1 ;
25870 int ecode1 = 0 ;
25871 PyObject * obj0 = 0 ;
25872 char * kwnames[] = {
25873 (char *) "winid", NULL
25874 };
25875
25876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25877 if (obj0) {
25878 ecode1 = SWIG_AsVal_int(obj0, &val1);
25879 if (!SWIG_IsOK(ecode1)) {
25880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25881 }
25882 arg1 = static_cast< int >(val1);
25883 }
25884 {
25885 PyThreadState* __tstate = wxPyBeginAllowThreads();
25886 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25891 return resultobj;
25892 fail:
25893 return NULL;
25894 }
25895
25896
25897 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25898 PyObject *resultobj = 0;
25899 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25900 bool arg2 ;
25901 void *argp1 = 0 ;
25902 int res1 = 0 ;
25903 bool val2 ;
25904 int ecode2 = 0 ;
25905 PyObject * obj0 = 0 ;
25906 PyObject * obj1 = 0 ;
25907 char * kwnames[] = {
25908 (char *) "self",(char *) "realized", NULL
25909 };
25910
25911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25913 if (!SWIG_IsOK(res1)) {
25914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25915 }
25916 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25917 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25918 if (!SWIG_IsOK(ecode2)) {
25919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25920 }
25921 arg2 = static_cast< bool >(val2);
25922 {
25923 PyThreadState* __tstate = wxPyBeginAllowThreads();
25924 (arg1)->SetPaletteRealized(arg2);
25925 wxPyEndAllowThreads(__tstate);
25926 if (PyErr_Occurred()) SWIG_fail;
25927 }
25928 resultobj = SWIG_Py_Void();
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25936 PyObject *resultobj = 0;
25937 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25938 bool result;
25939 void *argp1 = 0 ;
25940 int res1 = 0 ;
25941 PyObject *swig_obj[1] ;
25942
25943 if (!args) SWIG_fail;
25944 swig_obj[0] = args;
25945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25946 if (!SWIG_IsOK(res1)) {
25947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25948 }
25949 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25950 {
25951 PyThreadState* __tstate = wxPyBeginAllowThreads();
25952 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25953 wxPyEndAllowThreads(__tstate);
25954 if (PyErr_Occurred()) SWIG_fail;
25955 }
25956 {
25957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25958 }
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25966 PyObject *obj;
25967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25968 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25969 return SWIG_Py_Void();
25970 }
25971
25972 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25973 return SWIG_Python_InitShadowInstance(args);
25974 }
25975
25976 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25977 PyObject *resultobj = 0;
25978 wxNavigationKeyEvent *result = 0 ;
25979
25980 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25981 {
25982 PyThreadState* __tstate = wxPyBeginAllowThreads();
25983 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25988 return resultobj;
25989 fail:
25990 return NULL;
25991 }
25992
25993
25994 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25995 PyObject *resultobj = 0;
25996 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25997 bool result;
25998 void *argp1 = 0 ;
25999 int res1 = 0 ;
26000 PyObject *swig_obj[1] ;
26001
26002 if (!args) SWIG_fail;
26003 swig_obj[0] = args;
26004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26005 if (!SWIG_IsOK(res1)) {
26006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26007 }
26008 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26009 {
26010 PyThreadState* __tstate = wxPyBeginAllowThreads();
26011 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26012 wxPyEndAllowThreads(__tstate);
26013 if (PyErr_Occurred()) SWIG_fail;
26014 }
26015 {
26016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26017 }
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj = 0;
26026 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26027 bool arg2 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 bool val2 ;
26031 int ecode2 = 0 ;
26032 PyObject * obj0 = 0 ;
26033 PyObject * obj1 = 0 ;
26034 char * kwnames[] = {
26035 (char *) "self",(char *) "forward", NULL
26036 };
26037
26038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26040 if (!SWIG_IsOK(res1)) {
26041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26042 }
26043 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26045 if (!SWIG_IsOK(ecode2)) {
26046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26047 }
26048 arg2 = static_cast< bool >(val2);
26049 {
26050 PyThreadState* __tstate = wxPyBeginAllowThreads();
26051 (arg1)->SetDirection(arg2);
26052 wxPyEndAllowThreads(__tstate);
26053 if (PyErr_Occurred()) SWIG_fail;
26054 }
26055 resultobj = SWIG_Py_Void();
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26063 PyObject *resultobj = 0;
26064 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26065 bool result;
26066 void *argp1 = 0 ;
26067 int res1 = 0 ;
26068 PyObject *swig_obj[1] ;
26069
26070 if (!args) SWIG_fail;
26071 swig_obj[0] = args;
26072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26073 if (!SWIG_IsOK(res1)) {
26074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26075 }
26076 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26080 wxPyEndAllowThreads(__tstate);
26081 if (PyErr_Occurred()) SWIG_fail;
26082 }
26083 {
26084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26085 }
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj = 0;
26094 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26095 bool arg2 ;
26096 void *argp1 = 0 ;
26097 int res1 = 0 ;
26098 bool val2 ;
26099 int ecode2 = 0 ;
26100 PyObject * obj0 = 0 ;
26101 PyObject * obj1 = 0 ;
26102 char * kwnames[] = {
26103 (char *) "self",(char *) "ischange", NULL
26104 };
26105
26106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26108 if (!SWIG_IsOK(res1)) {
26109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26110 }
26111 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26112 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26113 if (!SWIG_IsOK(ecode2)) {
26114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26115 }
26116 arg2 = static_cast< bool >(val2);
26117 {
26118 PyThreadState* __tstate = wxPyBeginAllowThreads();
26119 (arg1)->SetWindowChange(arg2);
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 resultobj = SWIG_Py_Void();
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26131 PyObject *resultobj = 0;
26132 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26133 bool result;
26134 void *argp1 = 0 ;
26135 int res1 = 0 ;
26136 PyObject *swig_obj[1] ;
26137
26138 if (!args) SWIG_fail;
26139 swig_obj[0] = args;
26140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26141 if (!SWIG_IsOK(res1)) {
26142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26143 }
26144 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 {
26152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26153 }
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26161 PyObject *resultobj = 0;
26162 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26163 bool arg2 ;
26164 void *argp1 = 0 ;
26165 int res1 = 0 ;
26166 bool val2 ;
26167 int ecode2 = 0 ;
26168 PyObject * obj0 = 0 ;
26169 PyObject * obj1 = 0 ;
26170 char * kwnames[] = {
26171 (char *) "self",(char *) "bIs", NULL
26172 };
26173
26174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26176 if (!SWIG_IsOK(res1)) {
26177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26178 }
26179 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26180 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26181 if (!SWIG_IsOK(ecode2)) {
26182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26183 }
26184 arg2 = static_cast< bool >(val2);
26185 {
26186 PyThreadState* __tstate = wxPyBeginAllowThreads();
26187 (arg1)->SetFromTab(arg2);
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 resultobj = SWIG_Py_Void();
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26199 PyObject *resultobj = 0;
26200 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26201 long arg2 ;
26202 void *argp1 = 0 ;
26203 int res1 = 0 ;
26204 long val2 ;
26205 int ecode2 = 0 ;
26206 PyObject * obj0 = 0 ;
26207 PyObject * obj1 = 0 ;
26208 char * kwnames[] = {
26209 (char *) "self",(char *) "flags", NULL
26210 };
26211
26212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26214 if (!SWIG_IsOK(res1)) {
26215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26216 }
26217 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26218 ecode2 = SWIG_AsVal_long(obj1, &val2);
26219 if (!SWIG_IsOK(ecode2)) {
26220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26221 }
26222 arg2 = static_cast< long >(val2);
26223 {
26224 PyThreadState* __tstate = wxPyBeginAllowThreads();
26225 (arg1)->SetFlags(arg2);
26226 wxPyEndAllowThreads(__tstate);
26227 if (PyErr_Occurred()) SWIG_fail;
26228 }
26229 resultobj = SWIG_Py_Void();
26230 return resultobj;
26231 fail:
26232 return NULL;
26233 }
26234
26235
26236 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26237 PyObject *resultobj = 0;
26238 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26239 wxWindow *result = 0 ;
26240 void *argp1 = 0 ;
26241 int res1 = 0 ;
26242 PyObject *swig_obj[1] ;
26243
26244 if (!args) SWIG_fail;
26245 swig_obj[0] = args;
26246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26247 if (!SWIG_IsOK(res1)) {
26248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26249 }
26250 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26251 {
26252 PyThreadState* __tstate = wxPyBeginAllowThreads();
26253 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26254 wxPyEndAllowThreads(__tstate);
26255 if (PyErr_Occurred()) SWIG_fail;
26256 }
26257 {
26258 resultobj = wxPyMake_wxObject(result, (bool)0);
26259 }
26260 return resultobj;
26261 fail:
26262 return NULL;
26263 }
26264
26265
26266 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26267 PyObject *resultobj = 0;
26268 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26269 wxWindow *arg2 = (wxWindow *) 0 ;
26270 void *argp1 = 0 ;
26271 int res1 = 0 ;
26272 void *argp2 = 0 ;
26273 int res2 = 0 ;
26274 PyObject * obj0 = 0 ;
26275 PyObject * obj1 = 0 ;
26276 char * kwnames[] = {
26277 (char *) "self",(char *) "win", NULL
26278 };
26279
26280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26282 if (!SWIG_IsOK(res1)) {
26283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26284 }
26285 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26287 if (!SWIG_IsOK(res2)) {
26288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26289 }
26290 arg2 = reinterpret_cast< wxWindow * >(argp2);
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 (arg1)->SetCurrentFocus(arg2);
26294 wxPyEndAllowThreads(__tstate);
26295 if (PyErr_Occurred()) SWIG_fail;
26296 }
26297 resultobj = SWIG_Py_Void();
26298 return resultobj;
26299 fail:
26300 return NULL;
26301 }
26302
26303
26304 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 PyObject *obj;
26306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26307 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26308 return SWIG_Py_Void();
26309 }
26310
26311 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26312 return SWIG_Python_InitShadowInstance(args);
26313 }
26314
26315 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj = 0;
26317 wxWindow *arg1 = (wxWindow *) NULL ;
26318 wxWindowCreateEvent *result = 0 ;
26319 void *argp1 = 0 ;
26320 int res1 = 0 ;
26321 PyObject * obj0 = 0 ;
26322 char * kwnames[] = {
26323 (char *) "win", NULL
26324 };
26325
26326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26327 if (obj0) {
26328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26329 if (!SWIG_IsOK(res1)) {
26330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26331 }
26332 arg1 = reinterpret_cast< wxWindow * >(argp1);
26333 }
26334 {
26335 PyThreadState* __tstate = wxPyBeginAllowThreads();
26336 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26337 wxPyEndAllowThreads(__tstate);
26338 if (PyErr_Occurred()) SWIG_fail;
26339 }
26340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26341 return resultobj;
26342 fail:
26343 return NULL;
26344 }
26345
26346
26347 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26348 PyObject *resultobj = 0;
26349 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26350 wxWindow *result = 0 ;
26351 void *argp1 = 0 ;
26352 int res1 = 0 ;
26353 PyObject *swig_obj[1] ;
26354
26355 if (!args) SWIG_fail;
26356 swig_obj[0] = args;
26357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26360 }
26361 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26362 {
26363 PyThreadState* __tstate = wxPyBeginAllowThreads();
26364 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26365 wxPyEndAllowThreads(__tstate);
26366 if (PyErr_Occurred()) SWIG_fail;
26367 }
26368 {
26369 resultobj = wxPyMake_wxObject(result, (bool)0);
26370 }
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26378 PyObject *obj;
26379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26380 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26381 return SWIG_Py_Void();
26382 }
26383
26384 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26385 return SWIG_Python_InitShadowInstance(args);
26386 }
26387
26388 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26389 PyObject *resultobj = 0;
26390 wxWindow *arg1 = (wxWindow *) NULL ;
26391 wxWindowDestroyEvent *result = 0 ;
26392 void *argp1 = 0 ;
26393 int res1 = 0 ;
26394 PyObject * obj0 = 0 ;
26395 char * kwnames[] = {
26396 (char *) "win", NULL
26397 };
26398
26399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26400 if (obj0) {
26401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26402 if (!SWIG_IsOK(res1)) {
26403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26404 }
26405 arg1 = reinterpret_cast< wxWindow * >(argp1);
26406 }
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26421 PyObject *resultobj = 0;
26422 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26423 wxWindow *result = 0 ;
26424 void *argp1 = 0 ;
26425 int res1 = 0 ;
26426 PyObject *swig_obj[1] ;
26427
26428 if (!args) SWIG_fail;
26429 swig_obj[0] = args;
26430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26431 if (!SWIG_IsOK(res1)) {
26432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26433 }
26434 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26435 {
26436 PyThreadState* __tstate = wxPyBeginAllowThreads();
26437 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 {
26442 resultobj = wxPyMake_wxObject(result, (bool)0);
26443 }
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26451 PyObject *obj;
26452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26453 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26454 return SWIG_Py_Void();
26455 }
26456
26457 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26458 return SWIG_Python_InitShadowInstance(args);
26459 }
26460
26461 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26462 PyObject *resultobj = 0;
26463 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26464 int arg2 = (int) 0 ;
26465 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26466 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26467 wxContextMenuEvent *result = 0 ;
26468 int val1 ;
26469 int ecode1 = 0 ;
26470 int val2 ;
26471 int ecode2 = 0 ;
26472 wxPoint temp3 ;
26473 PyObject * obj0 = 0 ;
26474 PyObject * obj1 = 0 ;
26475 PyObject * obj2 = 0 ;
26476 char * kwnames[] = {
26477 (char *) "type",(char *) "winid",(char *) "pt", NULL
26478 };
26479
26480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26481 if (obj0) {
26482 ecode1 = SWIG_AsVal_int(obj0, &val1);
26483 if (!SWIG_IsOK(ecode1)) {
26484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26485 }
26486 arg1 = static_cast< wxEventType >(val1);
26487 }
26488 if (obj1) {
26489 ecode2 = SWIG_AsVal_int(obj1, &val2);
26490 if (!SWIG_IsOK(ecode2)) {
26491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26492 }
26493 arg2 = static_cast< int >(val2);
26494 }
26495 if (obj2) {
26496 {
26497 arg3 = &temp3;
26498 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26499 }
26500 }
26501 {
26502 PyThreadState* __tstate = wxPyBeginAllowThreads();
26503 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26504 wxPyEndAllowThreads(__tstate);
26505 if (PyErr_Occurred()) SWIG_fail;
26506 }
26507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26508 return resultobj;
26509 fail:
26510 return NULL;
26511 }
26512
26513
26514 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26515 PyObject *resultobj = 0;
26516 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26517 wxPoint *result = 0 ;
26518 void *argp1 = 0 ;
26519 int res1 = 0 ;
26520 PyObject *swig_obj[1] ;
26521
26522 if (!args) SWIG_fail;
26523 swig_obj[0] = args;
26524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26525 if (!SWIG_IsOK(res1)) {
26526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26527 }
26528 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26529 {
26530 PyThreadState* __tstate = wxPyBeginAllowThreads();
26531 {
26532 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26533 result = (wxPoint *) &_result_ref;
26534 }
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26539 return resultobj;
26540 fail:
26541 return NULL;
26542 }
26543
26544
26545 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26546 PyObject *resultobj = 0;
26547 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26548 wxPoint *arg2 = 0 ;
26549 void *argp1 = 0 ;
26550 int res1 = 0 ;
26551 wxPoint temp2 ;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554 char * kwnames[] = {
26555 (char *) "self",(char *) "pos", NULL
26556 };
26557
26558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26560 if (!SWIG_IsOK(res1)) {
26561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26562 }
26563 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26564 {
26565 arg2 = &temp2;
26566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26567 }
26568 {
26569 PyThreadState* __tstate = wxPyBeginAllowThreads();
26570 (arg1)->SetPosition((wxPoint const &)*arg2);
26571 wxPyEndAllowThreads(__tstate);
26572 if (PyErr_Occurred()) SWIG_fail;
26573 }
26574 resultobj = SWIG_Py_Void();
26575 return resultobj;
26576 fail:
26577 return NULL;
26578 }
26579
26580
26581 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26582 PyObject *obj;
26583 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26584 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26585 return SWIG_Py_Void();
26586 }
26587
26588 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26589 return SWIG_Python_InitShadowInstance(args);
26590 }
26591
26592 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26593 PyObject *resultobj = 0;
26594 wxIdleEvent *result = 0 ;
26595
26596 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26597 {
26598 PyThreadState* __tstate = wxPyBeginAllowThreads();
26599 result = (wxIdleEvent *)new wxIdleEvent();
26600 wxPyEndAllowThreads(__tstate);
26601 if (PyErr_Occurred()) SWIG_fail;
26602 }
26603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26604 return resultobj;
26605 fail:
26606 return NULL;
26607 }
26608
26609
26610 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26611 PyObject *resultobj = 0;
26612 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26613 bool arg2 = (bool) true ;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 bool val2 ;
26617 int ecode2 = 0 ;
26618 PyObject * obj0 = 0 ;
26619 PyObject * obj1 = 0 ;
26620 char * kwnames[] = {
26621 (char *) "self",(char *) "needMore", NULL
26622 };
26623
26624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26626 if (!SWIG_IsOK(res1)) {
26627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26628 }
26629 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26630 if (obj1) {
26631 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26632 if (!SWIG_IsOK(ecode2)) {
26633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26634 }
26635 arg2 = static_cast< bool >(val2);
26636 }
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 (arg1)->RequestMore(arg2);
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 resultobj = SWIG_Py_Void();
26644 return resultobj;
26645 fail:
26646 return NULL;
26647 }
26648
26649
26650 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26651 PyObject *resultobj = 0;
26652 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26653 bool result;
26654 void *argp1 = 0 ;
26655 int res1 = 0 ;
26656 PyObject *swig_obj[1] ;
26657
26658 if (!args) SWIG_fail;
26659 swig_obj[0] = args;
26660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26661 if (!SWIG_IsOK(res1)) {
26662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26663 }
26664 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 {
26672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26673 }
26674 return resultobj;
26675 fail:
26676 return NULL;
26677 }
26678
26679
26680 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26681 PyObject *resultobj = 0;
26682 wxIdleMode arg1 ;
26683 int val1 ;
26684 int ecode1 = 0 ;
26685 PyObject * obj0 = 0 ;
26686 char * kwnames[] = {
26687 (char *) "mode", NULL
26688 };
26689
26690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26691 ecode1 = SWIG_AsVal_int(obj0, &val1);
26692 if (!SWIG_IsOK(ecode1)) {
26693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26694 }
26695 arg1 = static_cast< wxIdleMode >(val1);
26696 {
26697 PyThreadState* __tstate = wxPyBeginAllowThreads();
26698 wxIdleEvent::SetMode(arg1);
26699 wxPyEndAllowThreads(__tstate);
26700 if (PyErr_Occurred()) SWIG_fail;
26701 }
26702 resultobj = SWIG_Py_Void();
26703 return resultobj;
26704 fail:
26705 return NULL;
26706 }
26707
26708
26709 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26710 PyObject *resultobj = 0;
26711 wxIdleMode result;
26712
26713 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26714 {
26715 PyThreadState* __tstate = wxPyBeginAllowThreads();
26716 result = (wxIdleMode)wxIdleEvent::GetMode();
26717 wxPyEndAllowThreads(__tstate);
26718 if (PyErr_Occurred()) SWIG_fail;
26719 }
26720 resultobj = SWIG_From_int(static_cast< int >(result));
26721 return resultobj;
26722 fail:
26723 return NULL;
26724 }
26725
26726
26727 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26728 PyObject *resultobj = 0;
26729 wxWindow *arg1 = (wxWindow *) 0 ;
26730 bool result;
26731 void *argp1 = 0 ;
26732 int res1 = 0 ;
26733 PyObject * obj0 = 0 ;
26734 char * kwnames[] = {
26735 (char *) "win", NULL
26736 };
26737
26738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) 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 '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26742 }
26743 arg1 = reinterpret_cast< wxWindow * >(argp1);
26744 {
26745 PyThreadState* __tstate = wxPyBeginAllowThreads();
26746 result = (bool)wxIdleEvent::CanSend(arg1);
26747 wxPyEndAllowThreads(__tstate);
26748 if (PyErr_Occurred()) SWIG_fail;
26749 }
26750 {
26751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26752 }
26753 return resultobj;
26754 fail:
26755 return NULL;
26756 }
26757
26758
26759 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26760 PyObject *obj;
26761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26762 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26763 return SWIG_Py_Void();
26764 }
26765
26766 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26767 return SWIG_Python_InitShadowInstance(args);
26768 }
26769
26770 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj = 0;
26772 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26773 int arg2 = (int) 0 ;
26774 wxClipboardTextEvent *result = 0 ;
26775 int val1 ;
26776 int ecode1 = 0 ;
26777 int val2 ;
26778 int ecode2 = 0 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char * kwnames[] = {
26782 (char *) "type",(char *) "winid", NULL
26783 };
26784
26785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26786 if (obj0) {
26787 ecode1 = SWIG_AsVal_int(obj0, &val1);
26788 if (!SWIG_IsOK(ecode1)) {
26789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26790 }
26791 arg1 = static_cast< wxEventType >(val1);
26792 }
26793 if (obj1) {
26794 ecode2 = SWIG_AsVal_int(obj1, &val2);
26795 if (!SWIG_IsOK(ecode2)) {
26796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26797 }
26798 arg2 = static_cast< int >(val2);
26799 }
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *obj;
26815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26816 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26817 return SWIG_Py_Void();
26818 }
26819
26820 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26821 return SWIG_Python_InitShadowInstance(args);
26822 }
26823
26824 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj = 0;
26826 int arg1 = (int) 0 ;
26827 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26828 wxPyEvent *result = 0 ;
26829 int val1 ;
26830 int ecode1 = 0 ;
26831 int val2 ;
26832 int ecode2 = 0 ;
26833 PyObject * obj0 = 0 ;
26834 PyObject * obj1 = 0 ;
26835 char * kwnames[] = {
26836 (char *) "winid",(char *) "eventType", NULL
26837 };
26838
26839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26840 if (obj0) {
26841 ecode1 = SWIG_AsVal_int(obj0, &val1);
26842 if (!SWIG_IsOK(ecode1)) {
26843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26844 }
26845 arg1 = static_cast< int >(val1);
26846 }
26847 if (obj1) {
26848 ecode2 = SWIG_AsVal_int(obj1, &val2);
26849 if (!SWIG_IsOK(ecode2)) {
26850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26851 }
26852 arg2 = static_cast< wxEventType >(val2);
26853 }
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26861 return resultobj;
26862 fail:
26863 return NULL;
26864 }
26865
26866
26867 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26868 PyObject *resultobj = 0;
26869 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26870 void *argp1 = 0 ;
26871 int res1 = 0 ;
26872 PyObject *swig_obj[1] ;
26873
26874 if (!args) SWIG_fail;
26875 swig_obj[0] = args;
26876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26877 if (!SWIG_IsOK(res1)) {
26878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26879 }
26880 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26881 {
26882 PyThreadState* __tstate = wxPyBeginAllowThreads();
26883 delete arg1;
26884
26885 wxPyEndAllowThreads(__tstate);
26886 if (PyErr_Occurred()) SWIG_fail;
26887 }
26888 resultobj = SWIG_Py_Void();
26889 return resultobj;
26890 fail:
26891 return NULL;
26892 }
26893
26894
26895 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26896 PyObject *resultobj = 0;
26897 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26898 PyObject *arg2 = (PyObject *) 0 ;
26899 void *argp1 = 0 ;
26900 int res1 = 0 ;
26901 PyObject * obj0 = 0 ;
26902 PyObject * obj1 = 0 ;
26903 char * kwnames[] = {
26904 (char *) "self",(char *) "self", NULL
26905 };
26906
26907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26909 if (!SWIG_IsOK(res1)) {
26910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26911 }
26912 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26913 arg2 = obj1;
26914 {
26915 PyThreadState* __tstate = wxPyBeginAllowThreads();
26916 (arg1)->SetSelf(arg2);
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 resultobj = SWIG_Py_Void();
26921 return resultobj;
26922 fail:
26923 return NULL;
26924 }
26925
26926
26927 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26928 PyObject *resultobj = 0;
26929 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26930 PyObject *result = 0 ;
26931 void *argp1 = 0 ;
26932 int res1 = 0 ;
26933 PyObject *swig_obj[1] ;
26934
26935 if (!args) SWIG_fail;
26936 swig_obj[0] = args;
26937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26938 if (!SWIG_IsOK(res1)) {
26939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26940 }
26941 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26942 {
26943 PyThreadState* __tstate = wxPyBeginAllowThreads();
26944 result = (PyObject *)(arg1)->GetSelf();
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 resultobj = result;
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26956 PyObject *obj;
26957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26958 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26959 return SWIG_Py_Void();
26960 }
26961
26962 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26963 return SWIG_Python_InitShadowInstance(args);
26964 }
26965
26966 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26967 PyObject *resultobj = 0;
26968 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26969 int arg2 = (int) 0 ;
26970 wxPyCommandEvent *result = 0 ;
26971 int val1 ;
26972 int ecode1 = 0 ;
26973 int val2 ;
26974 int ecode2 = 0 ;
26975 PyObject * obj0 = 0 ;
26976 PyObject * obj1 = 0 ;
26977 char * kwnames[] = {
26978 (char *) "eventType",(char *) "id", NULL
26979 };
26980
26981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26982 if (obj0) {
26983 ecode1 = SWIG_AsVal_int(obj0, &val1);
26984 if (!SWIG_IsOK(ecode1)) {
26985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26986 }
26987 arg1 = static_cast< wxEventType >(val1);
26988 }
26989 if (obj1) {
26990 ecode2 = SWIG_AsVal_int(obj1, &val2);
26991 if (!SWIG_IsOK(ecode2)) {
26992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26993 }
26994 arg2 = static_cast< int >(val2);
26995 }
26996 {
26997 PyThreadState* __tstate = wxPyBeginAllowThreads();
26998 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26999 wxPyEndAllowThreads(__tstate);
27000 if (PyErr_Occurred()) SWIG_fail;
27001 }
27002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27003 return resultobj;
27004 fail:
27005 return NULL;
27006 }
27007
27008
27009 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27010 PyObject *resultobj = 0;
27011 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27012 void *argp1 = 0 ;
27013 int res1 = 0 ;
27014 PyObject *swig_obj[1] ;
27015
27016 if (!args) SWIG_fail;
27017 swig_obj[0] = args;
27018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27019 if (!SWIG_IsOK(res1)) {
27020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27021 }
27022 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 delete arg1;
27026
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 resultobj = SWIG_Py_Void();
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27038 PyObject *resultobj = 0;
27039 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27040 PyObject *arg2 = (PyObject *) 0 ;
27041 void *argp1 = 0 ;
27042 int res1 = 0 ;
27043 PyObject * obj0 = 0 ;
27044 PyObject * obj1 = 0 ;
27045 char * kwnames[] = {
27046 (char *) "self",(char *) "self", NULL
27047 };
27048
27049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27051 if (!SWIG_IsOK(res1)) {
27052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27053 }
27054 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27055 arg2 = obj1;
27056 {
27057 PyThreadState* __tstate = wxPyBeginAllowThreads();
27058 (arg1)->SetSelf(arg2);
27059 wxPyEndAllowThreads(__tstate);
27060 if (PyErr_Occurred()) SWIG_fail;
27061 }
27062 resultobj = SWIG_Py_Void();
27063 return resultobj;
27064 fail:
27065 return NULL;
27066 }
27067
27068
27069 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27070 PyObject *resultobj = 0;
27071 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27072 PyObject *result = 0 ;
27073 void *argp1 = 0 ;
27074 int res1 = 0 ;
27075 PyObject *swig_obj[1] ;
27076
27077 if (!args) SWIG_fail;
27078 swig_obj[0] = args;
27079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27080 if (!SWIG_IsOK(res1)) {
27081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27082 }
27083 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 result = (PyObject *)(arg1)->GetSelf();
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 resultobj = result;
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27098 PyObject *obj;
27099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27100 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27101 return SWIG_Py_Void();
27102 }
27103
27104 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27105 return SWIG_Python_InitShadowInstance(args);
27106 }
27107
27108 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27109 PyObject *resultobj = 0;
27110 wxWindow *arg1 = (wxWindow *) 0 ;
27111 wxDateTime *arg2 = 0 ;
27112 wxEventType arg3 ;
27113 wxDateEvent *result = 0 ;
27114 void *argp1 = 0 ;
27115 int res1 = 0 ;
27116 void *argp2 = 0 ;
27117 int res2 = 0 ;
27118 int val3 ;
27119 int ecode3 = 0 ;
27120 PyObject * obj0 = 0 ;
27121 PyObject * obj1 = 0 ;
27122 PyObject * obj2 = 0 ;
27123 char * kwnames[] = {
27124 (char *) "win",(char *) "dt",(char *) "type", NULL
27125 };
27126
27127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27129 if (!SWIG_IsOK(res1)) {
27130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27131 }
27132 arg1 = reinterpret_cast< wxWindow * >(argp1);
27133 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27134 if (!SWIG_IsOK(res2)) {
27135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27136 }
27137 if (!argp2) {
27138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27139 }
27140 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27141 ecode3 = SWIG_AsVal_int(obj2, &val3);
27142 if (!SWIG_IsOK(ecode3)) {
27143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27144 }
27145 arg3 = static_cast< wxEventType >(val3);
27146 {
27147 PyThreadState* __tstate = wxPyBeginAllowThreads();
27148 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27149 wxPyEndAllowThreads(__tstate);
27150 if (PyErr_Occurred()) SWIG_fail;
27151 }
27152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27153 return resultobj;
27154 fail:
27155 return NULL;
27156 }
27157
27158
27159 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27160 PyObject *resultobj = 0;
27161 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27162 wxDateTime *result = 0 ;
27163 void *argp1 = 0 ;
27164 int res1 = 0 ;
27165 PyObject *swig_obj[1] ;
27166
27167 if (!args) SWIG_fail;
27168 swig_obj[0] = args;
27169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27170 if (!SWIG_IsOK(res1)) {
27171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27172 }
27173 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27174 {
27175 PyThreadState* __tstate = wxPyBeginAllowThreads();
27176 {
27177 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27178 result = (wxDateTime *) &_result_ref;
27179 }
27180 wxPyEndAllowThreads(__tstate);
27181 if (PyErr_Occurred()) SWIG_fail;
27182 }
27183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27184 return resultobj;
27185 fail:
27186 return NULL;
27187 }
27188
27189
27190 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27191 PyObject *resultobj = 0;
27192 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27193 wxDateTime *arg2 = 0 ;
27194 void *argp1 = 0 ;
27195 int res1 = 0 ;
27196 void *argp2 = 0 ;
27197 int res2 = 0 ;
27198 PyObject * obj0 = 0 ;
27199 PyObject * obj1 = 0 ;
27200 char * kwnames[] = {
27201 (char *) "self",(char *) "date", NULL
27202 };
27203
27204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27206 if (!SWIG_IsOK(res1)) {
27207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27208 }
27209 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27210 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27211 if (!SWIG_IsOK(res2)) {
27212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27213 }
27214 if (!argp2) {
27215 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27216 }
27217 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27218 {
27219 PyThreadState* __tstate = wxPyBeginAllowThreads();
27220 (arg1)->SetDate((wxDateTime const &)*arg2);
27221 wxPyEndAllowThreads(__tstate);
27222 if (PyErr_Occurred()) SWIG_fail;
27223 }
27224 resultobj = SWIG_Py_Void();
27225 return resultobj;
27226 fail:
27227 return NULL;
27228 }
27229
27230
27231 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27232 PyObject *obj;
27233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27234 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27235 return SWIG_Py_Void();
27236 }
27237
27238 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27239 return SWIG_Python_InitShadowInstance(args);
27240 }
27241
27242 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27243 PyObject *resultobj = 0;
27244 wxPyApp *result = 0 ;
27245
27246 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27247 {
27248 PyThreadState* __tstate = wxPyBeginAllowThreads();
27249 result = (wxPyApp *)new_wxPyApp();
27250 wxPyEndAllowThreads(__tstate);
27251 if (PyErr_Occurred()) SWIG_fail;
27252 }
27253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27254 return resultobj;
27255 fail:
27256 return NULL;
27257 }
27258
27259
27260 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27261 PyObject *resultobj = 0;
27262 wxPyApp *arg1 = (wxPyApp *) 0 ;
27263 void *argp1 = 0 ;
27264 int res1 = 0 ;
27265 PyObject *swig_obj[1] ;
27266
27267 if (!args) SWIG_fail;
27268 swig_obj[0] = args;
27269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27270 if (!SWIG_IsOK(res1)) {
27271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27272 }
27273 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 delete arg1;
27277
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 resultobj = SWIG_Py_Void();
27282 return resultobj;
27283 fail:
27284 return NULL;
27285 }
27286
27287
27288 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27289 PyObject *resultobj = 0;
27290 wxPyApp *arg1 = (wxPyApp *) 0 ;
27291 PyObject *arg2 = (PyObject *) 0 ;
27292 PyObject *arg3 = (PyObject *) 0 ;
27293 bool arg4 ;
27294 void *argp1 = 0 ;
27295 int res1 = 0 ;
27296 bool val4 ;
27297 int ecode4 = 0 ;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 PyObject * obj2 = 0 ;
27301 PyObject * obj3 = 0 ;
27302 char * kwnames[] = {
27303 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27304 };
27305
27306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27308 if (!SWIG_IsOK(res1)) {
27309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27310 }
27311 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27312 arg2 = obj1;
27313 arg3 = obj2;
27314 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27315 if (!SWIG_IsOK(ecode4)) {
27316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27317 }
27318 arg4 = static_cast< bool >(val4);
27319 {
27320 PyThreadState* __tstate = wxPyBeginAllowThreads();
27321 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 resultobj = SWIG_Py_Void();
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27333 PyObject *resultobj = 0;
27334 wxPyApp *arg1 = (wxPyApp *) 0 ;
27335 wxString result;
27336 void *argp1 = 0 ;
27337 int res1 = 0 ;
27338 PyObject *swig_obj[1] ;
27339
27340 if (!args) SWIG_fail;
27341 swig_obj[0] = args;
27342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27343 if (!SWIG_IsOK(res1)) {
27344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27345 }
27346 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 result = ((wxPyApp const *)arg1)->GetAppName();
27350 wxPyEndAllowThreads(__tstate);
27351 if (PyErr_Occurred()) SWIG_fail;
27352 }
27353 {
27354 #if wxUSE_UNICODE
27355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27356 #else
27357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27358 #endif
27359 }
27360 return resultobj;
27361 fail:
27362 return NULL;
27363 }
27364
27365
27366 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27367 PyObject *resultobj = 0;
27368 wxPyApp *arg1 = (wxPyApp *) 0 ;
27369 wxString *arg2 = 0 ;
27370 void *argp1 = 0 ;
27371 int res1 = 0 ;
27372 bool temp2 = false ;
27373 PyObject * obj0 = 0 ;
27374 PyObject * obj1 = 0 ;
27375 char * kwnames[] = {
27376 (char *) "self",(char *) "name", NULL
27377 };
27378
27379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27381 if (!SWIG_IsOK(res1)) {
27382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27383 }
27384 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27385 {
27386 arg2 = wxString_in_helper(obj1);
27387 if (arg2 == NULL) SWIG_fail;
27388 temp2 = true;
27389 }
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 (arg1)->SetAppName((wxString const &)*arg2);
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 resultobj = SWIG_Py_Void();
27397 {
27398 if (temp2)
27399 delete arg2;
27400 }
27401 return resultobj;
27402 fail:
27403 {
27404 if (temp2)
27405 delete arg2;
27406 }
27407 return NULL;
27408 }
27409
27410
27411 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27412 PyObject *resultobj = 0;
27413 wxPyApp *arg1 = (wxPyApp *) 0 ;
27414 wxString result;
27415 void *argp1 = 0 ;
27416 int res1 = 0 ;
27417 PyObject *swig_obj[1] ;
27418
27419 if (!args) SWIG_fail;
27420 swig_obj[0] = args;
27421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27422 if (!SWIG_IsOK(res1)) {
27423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27424 }
27425 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27426 {
27427 PyThreadState* __tstate = wxPyBeginAllowThreads();
27428 result = ((wxPyApp const *)arg1)->GetClassName();
27429 wxPyEndAllowThreads(__tstate);
27430 if (PyErr_Occurred()) SWIG_fail;
27431 }
27432 {
27433 #if wxUSE_UNICODE
27434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27435 #else
27436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27437 #endif
27438 }
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27446 PyObject *resultobj = 0;
27447 wxPyApp *arg1 = (wxPyApp *) 0 ;
27448 wxString *arg2 = 0 ;
27449 void *argp1 = 0 ;
27450 int res1 = 0 ;
27451 bool temp2 = false ;
27452 PyObject * obj0 = 0 ;
27453 PyObject * obj1 = 0 ;
27454 char * kwnames[] = {
27455 (char *) "self",(char *) "name", NULL
27456 };
27457
27458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27460 if (!SWIG_IsOK(res1)) {
27461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27462 }
27463 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27464 {
27465 arg2 = wxString_in_helper(obj1);
27466 if (arg2 == NULL) SWIG_fail;
27467 temp2 = true;
27468 }
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 (arg1)->SetClassName((wxString const &)*arg2);
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 resultobj = SWIG_Py_Void();
27476 {
27477 if (temp2)
27478 delete arg2;
27479 }
27480 return resultobj;
27481 fail:
27482 {
27483 if (temp2)
27484 delete arg2;
27485 }
27486 return NULL;
27487 }
27488
27489
27490 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27491 PyObject *resultobj = 0;
27492 wxPyApp *arg1 = (wxPyApp *) 0 ;
27493 wxString *result = 0 ;
27494 void *argp1 = 0 ;
27495 int res1 = 0 ;
27496 PyObject *swig_obj[1] ;
27497
27498 if (!args) SWIG_fail;
27499 swig_obj[0] = args;
27500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27501 if (!SWIG_IsOK(res1)) {
27502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27503 }
27504 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 {
27508 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27509 result = (wxString *) &_result_ref;
27510 }
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 {
27515 #if wxUSE_UNICODE
27516 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27517 #else
27518 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27519 #endif
27520 }
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 wxPyApp *arg1 = (wxPyApp *) 0 ;
27530 wxString *arg2 = 0 ;
27531 void *argp1 = 0 ;
27532 int res1 = 0 ;
27533 bool temp2 = false ;
27534 PyObject * obj0 = 0 ;
27535 PyObject * obj1 = 0 ;
27536 char * kwnames[] = {
27537 (char *) "self",(char *) "name", NULL
27538 };
27539
27540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27542 if (!SWIG_IsOK(res1)) {
27543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27544 }
27545 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27546 {
27547 arg2 = wxString_in_helper(obj1);
27548 if (arg2 == NULL) SWIG_fail;
27549 temp2 = true;
27550 }
27551 {
27552 PyThreadState* __tstate = wxPyBeginAllowThreads();
27553 (arg1)->SetVendorName((wxString const &)*arg2);
27554 wxPyEndAllowThreads(__tstate);
27555 if (PyErr_Occurred()) SWIG_fail;
27556 }
27557 resultobj = SWIG_Py_Void();
27558 {
27559 if (temp2)
27560 delete arg2;
27561 }
27562 return resultobj;
27563 fail:
27564 {
27565 if (temp2)
27566 delete arg2;
27567 }
27568 return NULL;
27569 }
27570
27571
27572 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27573 PyObject *resultobj = 0;
27574 wxPyApp *arg1 = (wxPyApp *) 0 ;
27575 wxAppTraits *result = 0 ;
27576 void *argp1 = 0 ;
27577 int res1 = 0 ;
27578 PyObject *swig_obj[1] ;
27579
27580 if (!args) SWIG_fail;
27581 swig_obj[0] = args;
27582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27583 if (!SWIG_IsOK(res1)) {
27584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27585 }
27586 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27587 {
27588 PyThreadState* __tstate = wxPyBeginAllowThreads();
27589 result = (wxAppTraits *)(arg1)->GetTraits();
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27601 PyObject *resultobj = 0;
27602 wxPyApp *arg1 = (wxPyApp *) 0 ;
27603 void *argp1 = 0 ;
27604 int res1 = 0 ;
27605 PyObject *swig_obj[1] ;
27606
27607 if (!args) SWIG_fail;
27608 swig_obj[0] = args;
27609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27610 if (!SWIG_IsOK(res1)) {
27611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27612 }
27613 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27614 {
27615 PyThreadState* __tstate = wxPyBeginAllowThreads();
27616 (arg1)->ProcessPendingEvents();
27617 wxPyEndAllowThreads(__tstate);
27618 if (PyErr_Occurred()) SWIG_fail;
27619 }
27620 resultobj = SWIG_Py_Void();
27621 return resultobj;
27622 fail:
27623 return NULL;
27624 }
27625
27626
27627 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27628 PyObject *resultobj = 0;
27629 wxPyApp *arg1 = (wxPyApp *) 0 ;
27630 bool arg2 = (bool) false ;
27631 bool result;
27632 void *argp1 = 0 ;
27633 int res1 = 0 ;
27634 bool val2 ;
27635 int ecode2 = 0 ;
27636 PyObject * obj0 = 0 ;
27637 PyObject * obj1 = 0 ;
27638 char * kwnames[] = {
27639 (char *) "self",(char *) "onlyIfNeeded", NULL
27640 };
27641
27642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27644 if (!SWIG_IsOK(res1)) {
27645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27646 }
27647 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27648 if (obj1) {
27649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27650 if (!SWIG_IsOK(ecode2)) {
27651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27652 }
27653 arg2 = static_cast< bool >(val2);
27654 }
27655 {
27656 PyThreadState* __tstate = wxPyBeginAllowThreads();
27657 result = (bool)(arg1)->Yield(arg2);
27658 wxPyEndAllowThreads(__tstate);
27659 if (PyErr_Occurred()) SWIG_fail;
27660 }
27661 {
27662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27663 }
27664 return resultobj;
27665 fail:
27666 return NULL;
27667 }
27668
27669
27670 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27671 PyObject *resultobj = 0;
27672 wxPyApp *arg1 = (wxPyApp *) 0 ;
27673 void *argp1 = 0 ;
27674 int res1 = 0 ;
27675 PyObject *swig_obj[1] ;
27676
27677 if (!args) SWIG_fail;
27678 swig_obj[0] = args;
27679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27680 if (!SWIG_IsOK(res1)) {
27681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27682 }
27683 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 (arg1)->WakeUpIdle();
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 resultobj = SWIG_Py_Void();
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27698 PyObject *resultobj = 0;
27699 bool result;
27700
27701 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27702 {
27703 PyThreadState* __tstate = wxPyBeginAllowThreads();
27704 result = (bool)wxPyApp::IsMainLoopRunning();
27705 wxPyEndAllowThreads(__tstate);
27706 if (PyErr_Occurred()) SWIG_fail;
27707 }
27708 {
27709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27710 }
27711 return resultobj;
27712 fail:
27713 return NULL;
27714 }
27715
27716
27717 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27718 PyObject *resultobj = 0;
27719 wxPyApp *arg1 = (wxPyApp *) 0 ;
27720 int result;
27721 void *argp1 = 0 ;
27722 int res1 = 0 ;
27723 PyObject *swig_obj[1] ;
27724
27725 if (!args) SWIG_fail;
27726 swig_obj[0] = args;
27727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27728 if (!SWIG_IsOK(res1)) {
27729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27730 }
27731 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27732 {
27733 PyThreadState* __tstate = wxPyBeginAllowThreads();
27734 result = (int)(arg1)->MainLoop();
27735 wxPyEndAllowThreads(__tstate);
27736 if (PyErr_Occurred()) SWIG_fail;
27737 }
27738 resultobj = SWIG_From_int(static_cast< int >(result));
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27746 PyObject *resultobj = 0;
27747 wxPyApp *arg1 = (wxPyApp *) 0 ;
27748 void *argp1 = 0 ;
27749 int res1 = 0 ;
27750 PyObject *swig_obj[1] ;
27751
27752 if (!args) SWIG_fail;
27753 swig_obj[0] = args;
27754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27755 if (!SWIG_IsOK(res1)) {
27756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27757 }
27758 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27759 {
27760 PyThreadState* __tstate = wxPyBeginAllowThreads();
27761 (arg1)->Exit();
27762 wxPyEndAllowThreads(__tstate);
27763 if (PyErr_Occurred()) SWIG_fail;
27764 }
27765 resultobj = SWIG_Py_Void();
27766 return resultobj;
27767 fail:
27768 return NULL;
27769 }
27770
27771
27772 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27773 PyObject *resultobj = 0;
27774 wxPyApp *arg1 = (wxPyApp *) 0 ;
27775 wxLayoutDirection result;
27776 void *argp1 = 0 ;
27777 int res1 = 0 ;
27778 PyObject *swig_obj[1] ;
27779
27780 if (!args) SWIG_fail;
27781 swig_obj[0] = args;
27782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27783 if (!SWIG_IsOK(res1)) {
27784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27785 }
27786 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27787 {
27788 PyThreadState* __tstate = wxPyBeginAllowThreads();
27789 result = ((wxPyApp const *)arg1)->GetLayoutDirection();
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27801 PyObject *resultobj = 0;
27802 wxPyApp *arg1 = (wxPyApp *) 0 ;
27803 void *argp1 = 0 ;
27804 int res1 = 0 ;
27805 PyObject *swig_obj[1] ;
27806
27807 if (!args) SWIG_fail;
27808 swig_obj[0] = args;
27809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27810 if (!SWIG_IsOK(res1)) {
27811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27812 }
27813 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 (arg1)->ExitMainLoop();
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 resultobj = SWIG_Py_Void();
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27828 PyObject *resultobj = 0;
27829 wxPyApp *arg1 = (wxPyApp *) 0 ;
27830 bool result;
27831 void *argp1 = 0 ;
27832 int res1 = 0 ;
27833 PyObject *swig_obj[1] ;
27834
27835 if (!args) SWIG_fail;
27836 swig_obj[0] = args;
27837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27838 if (!SWIG_IsOK(res1)) {
27839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27840 }
27841 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (bool)(arg1)->Pending();
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 {
27849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27850 }
27851 return resultobj;
27852 fail:
27853 return NULL;
27854 }
27855
27856
27857 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27858 PyObject *resultobj = 0;
27859 wxPyApp *arg1 = (wxPyApp *) 0 ;
27860 bool result;
27861 void *argp1 = 0 ;
27862 int res1 = 0 ;
27863 PyObject *swig_obj[1] ;
27864
27865 if (!args) SWIG_fail;
27866 swig_obj[0] = args;
27867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27868 if (!SWIG_IsOK(res1)) {
27869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27870 }
27871 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = (bool)(arg1)->Dispatch();
27875 wxPyEndAllowThreads(__tstate);
27876 if (PyErr_Occurred()) SWIG_fail;
27877 }
27878 {
27879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27880 }
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27888 PyObject *resultobj = 0;
27889 wxPyApp *arg1 = (wxPyApp *) 0 ;
27890 bool result;
27891 void *argp1 = 0 ;
27892 int res1 = 0 ;
27893 PyObject *swig_obj[1] ;
27894
27895 if (!args) SWIG_fail;
27896 swig_obj[0] = args;
27897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27898 if (!SWIG_IsOK(res1)) {
27899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27900 }
27901 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27902 {
27903 PyThreadState* __tstate = wxPyBeginAllowThreads();
27904 result = (bool)(arg1)->ProcessIdle();
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 {
27909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27910 }
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27918 PyObject *resultobj = 0;
27919 wxPyApp *arg1 = (wxPyApp *) 0 ;
27920 wxWindow *arg2 = (wxWindow *) 0 ;
27921 wxIdleEvent *arg3 = 0 ;
27922 bool result;
27923 void *argp1 = 0 ;
27924 int res1 = 0 ;
27925 void *argp2 = 0 ;
27926 int res2 = 0 ;
27927 void *argp3 = 0 ;
27928 int res3 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 PyObject * obj1 = 0 ;
27931 PyObject * obj2 = 0 ;
27932 char * kwnames[] = {
27933 (char *) "self",(char *) "win",(char *) "event", NULL
27934 };
27935
27936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27940 }
27941 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27942 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27943 if (!SWIG_IsOK(res2)) {
27944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27945 }
27946 arg2 = reinterpret_cast< wxWindow * >(argp2);
27947 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27948 if (!SWIG_IsOK(res3)) {
27949 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27950 }
27951 if (!argp3) {
27952 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27953 }
27954 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27955 {
27956 PyThreadState* __tstate = wxPyBeginAllowThreads();
27957 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27958 wxPyEndAllowThreads(__tstate);
27959 if (PyErr_Occurred()) SWIG_fail;
27960 }
27961 {
27962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27963 }
27964 return resultobj;
27965 fail:
27966 return NULL;
27967 }
27968
27969
27970 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27971 PyObject *resultobj = 0;
27972 wxPyApp *arg1 = (wxPyApp *) 0 ;
27973 bool result;
27974 void *argp1 = 0 ;
27975 int res1 = 0 ;
27976 PyObject *swig_obj[1] ;
27977
27978 if (!args) SWIG_fail;
27979 swig_obj[0] = args;
27980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27981 if (!SWIG_IsOK(res1)) {
27982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27983 }
27984 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27985 {
27986 PyThreadState* __tstate = wxPyBeginAllowThreads();
27987 result = (bool)((wxPyApp const *)arg1)->IsActive();
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 {
27992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27993 }
27994 return resultobj;
27995 fail:
27996 return NULL;
27997 }
27998
27999
28000 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28001 PyObject *resultobj = 0;
28002 wxPyApp *arg1 = (wxPyApp *) 0 ;
28003 wxWindow *arg2 = (wxWindow *) 0 ;
28004 void *argp1 = 0 ;
28005 int res1 = 0 ;
28006 void *argp2 = 0 ;
28007 int res2 = 0 ;
28008 PyObject * obj0 = 0 ;
28009 PyObject * obj1 = 0 ;
28010 char * kwnames[] = {
28011 (char *) "self",(char *) "win", NULL
28012 };
28013
28014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28016 if (!SWIG_IsOK(res1)) {
28017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28018 }
28019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28020 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28021 if (!SWIG_IsOK(res2)) {
28022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28023 }
28024 arg2 = reinterpret_cast< wxWindow * >(argp2);
28025 {
28026 PyThreadState* __tstate = wxPyBeginAllowThreads();
28027 (arg1)->SetTopWindow(arg2);
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 resultobj = SWIG_Py_Void();
28032 return resultobj;
28033 fail:
28034 return NULL;
28035 }
28036
28037
28038 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28039 PyObject *resultobj = 0;
28040 wxPyApp *arg1 = (wxPyApp *) 0 ;
28041 wxWindow *result = 0 ;
28042 void *argp1 = 0 ;
28043 int res1 = 0 ;
28044 PyObject *swig_obj[1] ;
28045
28046 if (!args) SWIG_fail;
28047 swig_obj[0] = args;
28048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28049 if (!SWIG_IsOK(res1)) {
28050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28051 }
28052 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28056 wxPyEndAllowThreads(__tstate);
28057 if (PyErr_Occurred()) SWIG_fail;
28058 }
28059 {
28060 resultobj = wxPyMake_wxObject(result, (bool)0);
28061 }
28062 return resultobj;
28063 fail:
28064 return NULL;
28065 }
28066
28067
28068 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28069 PyObject *resultobj = 0;
28070 wxPyApp *arg1 = (wxPyApp *) 0 ;
28071 bool arg2 ;
28072 void *argp1 = 0 ;
28073 int res1 = 0 ;
28074 bool val2 ;
28075 int ecode2 = 0 ;
28076 PyObject * obj0 = 0 ;
28077 PyObject * obj1 = 0 ;
28078 char * kwnames[] = {
28079 (char *) "self",(char *) "flag", NULL
28080 };
28081
28082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28084 if (!SWIG_IsOK(res1)) {
28085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28086 }
28087 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28089 if (!SWIG_IsOK(ecode2)) {
28090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28091 }
28092 arg2 = static_cast< bool >(val2);
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 (arg1)->SetExitOnFrameDelete(arg2);
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 resultobj = SWIG_Py_Void();
28100 return resultobj;
28101 fail:
28102 return NULL;
28103 }
28104
28105
28106 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28107 PyObject *resultobj = 0;
28108 wxPyApp *arg1 = (wxPyApp *) 0 ;
28109 bool result;
28110 void *argp1 = 0 ;
28111 int res1 = 0 ;
28112 PyObject *swig_obj[1] ;
28113
28114 if (!args) SWIG_fail;
28115 swig_obj[0] = args;
28116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28117 if (!SWIG_IsOK(res1)) {
28118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28119 }
28120 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 {
28128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28129 }
28130 return resultobj;
28131 fail:
28132 return NULL;
28133 }
28134
28135
28136 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28137 PyObject *resultobj = 0;
28138 wxPyApp *arg1 = (wxPyApp *) 0 ;
28139 bool arg2 ;
28140 void *argp1 = 0 ;
28141 int res1 = 0 ;
28142 bool val2 ;
28143 int ecode2 = 0 ;
28144 PyObject * obj0 = 0 ;
28145 PyObject * obj1 = 0 ;
28146 char * kwnames[] = {
28147 (char *) "self",(char *) "flag", NULL
28148 };
28149
28150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28152 if (!SWIG_IsOK(res1)) {
28153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28154 }
28155 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28157 if (!SWIG_IsOK(ecode2)) {
28158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28159 }
28160 arg2 = static_cast< bool >(val2);
28161 {
28162 PyThreadState* __tstate = wxPyBeginAllowThreads();
28163 (arg1)->SetUseBestVisual(arg2);
28164 wxPyEndAllowThreads(__tstate);
28165 if (PyErr_Occurred()) SWIG_fail;
28166 }
28167 resultobj = SWIG_Py_Void();
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28175 PyObject *resultobj = 0;
28176 wxPyApp *arg1 = (wxPyApp *) 0 ;
28177 bool result;
28178 void *argp1 = 0 ;
28179 int res1 = 0 ;
28180 PyObject *swig_obj[1] ;
28181
28182 if (!args) SWIG_fail;
28183 swig_obj[0] = args;
28184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28185 if (!SWIG_IsOK(res1)) {
28186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28187 }
28188 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 {
28196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28197 }
28198 return resultobj;
28199 fail:
28200 return NULL;
28201 }
28202
28203
28204 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28205 PyObject *resultobj = 0;
28206 wxPyApp *arg1 = (wxPyApp *) 0 ;
28207 int arg2 ;
28208 void *argp1 = 0 ;
28209 int res1 = 0 ;
28210 int val2 ;
28211 int ecode2 = 0 ;
28212 PyObject * obj0 = 0 ;
28213 PyObject * obj1 = 0 ;
28214 char * kwnames[] = {
28215 (char *) "self",(char *) "mode", NULL
28216 };
28217
28218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28220 if (!SWIG_IsOK(res1)) {
28221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28222 }
28223 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28224 ecode2 = SWIG_AsVal_int(obj1, &val2);
28225 if (!SWIG_IsOK(ecode2)) {
28226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28227 }
28228 arg2 = static_cast< int >(val2);
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 (arg1)->SetPrintMode(arg2);
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_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28243 PyObject *resultobj = 0;
28244 wxPyApp *arg1 = (wxPyApp *) 0 ;
28245 int result;
28246 void *argp1 = 0 ;
28247 int res1 = 0 ;
28248 PyObject *swig_obj[1] ;
28249
28250 if (!args) SWIG_fail;
28251 swig_obj[0] = args;
28252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28253 if (!SWIG_IsOK(res1)) {
28254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28255 }
28256 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 resultobj = SWIG_From_int(static_cast< int >(result));
28264 return resultobj;
28265 fail:
28266 return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28271 PyObject *resultobj = 0;
28272 wxPyApp *arg1 = (wxPyApp *) 0 ;
28273 int arg2 ;
28274 void *argp1 = 0 ;
28275 int res1 = 0 ;
28276 int val2 ;
28277 int ecode2 = 0 ;
28278 PyObject * obj0 = 0 ;
28279 PyObject * obj1 = 0 ;
28280 char * kwnames[] = {
28281 (char *) "self",(char *) "mode", NULL
28282 };
28283
28284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28286 if (!SWIG_IsOK(res1)) {
28287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28288 }
28289 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28290 ecode2 = SWIG_AsVal_int(obj1, &val2);
28291 if (!SWIG_IsOK(ecode2)) {
28292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28293 }
28294 arg2 = static_cast< int >(val2);
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 (arg1)->SetAssertMode(arg2);
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 resultobj = SWIG_Py_Void();
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28309 PyObject *resultobj = 0;
28310 wxPyApp *arg1 = (wxPyApp *) 0 ;
28311 int result;
28312 void *argp1 = 0 ;
28313 int res1 = 0 ;
28314 PyObject *swig_obj[1] ;
28315
28316 if (!args) SWIG_fail;
28317 swig_obj[0] = args;
28318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28319 if (!SWIG_IsOK(res1)) {
28320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28321 }
28322 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (int)(arg1)->GetAssertMode();
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 resultobj = SWIG_From_int(static_cast< int >(result));
28330 return resultobj;
28331 fail:
28332 return NULL;
28333 }
28334
28335
28336 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28337 PyObject *resultobj = 0;
28338 bool result;
28339
28340 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 {
28348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28349 }
28350 return resultobj;
28351 fail:
28352 return NULL;
28353 }
28354
28355
28356 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28357 PyObject *resultobj = 0;
28358 long result;
28359
28360 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28361 {
28362 PyThreadState* __tstate = wxPyBeginAllowThreads();
28363 result = (long)wxPyApp::GetMacAboutMenuItemId();
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 resultobj = SWIG_From_long(static_cast< long >(result));
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28375 PyObject *resultobj = 0;
28376 long result;
28377
28378 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28379 {
28380 PyThreadState* __tstate = wxPyBeginAllowThreads();
28381 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28382 wxPyEndAllowThreads(__tstate);
28383 if (PyErr_Occurred()) SWIG_fail;
28384 }
28385 resultobj = SWIG_From_long(static_cast< long >(result));
28386 return resultobj;
28387 fail:
28388 return NULL;
28389 }
28390
28391
28392 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28393 PyObject *resultobj = 0;
28394 long result;
28395
28396 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28397 {
28398 PyThreadState* __tstate = wxPyBeginAllowThreads();
28399 result = (long)wxPyApp::GetMacExitMenuItemId();
28400 wxPyEndAllowThreads(__tstate);
28401 if (PyErr_Occurred()) SWIG_fail;
28402 }
28403 resultobj = SWIG_From_long(static_cast< long >(result));
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28411 PyObject *resultobj = 0;
28412 wxString result;
28413
28414 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28415 {
28416 PyThreadState* __tstate = wxPyBeginAllowThreads();
28417 result = wxPyApp::GetMacHelpMenuTitleName();
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 {
28422 #if wxUSE_UNICODE
28423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28424 #else
28425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28426 #endif
28427 }
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28435 PyObject *resultobj = 0;
28436 bool arg1 ;
28437 bool val1 ;
28438 int ecode1 = 0 ;
28439 PyObject * obj0 = 0 ;
28440 char * kwnames[] = {
28441 (char *) "val", NULL
28442 };
28443
28444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28445 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28446 if (!SWIG_IsOK(ecode1)) {
28447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28448 }
28449 arg1 = static_cast< bool >(val1);
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 resultobj = SWIG_Py_Void();
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28464 PyObject *resultobj = 0;
28465 long arg1 ;
28466 long val1 ;
28467 int ecode1 = 0 ;
28468 PyObject * obj0 = 0 ;
28469 char * kwnames[] = {
28470 (char *) "val", NULL
28471 };
28472
28473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28474 ecode1 = SWIG_AsVal_long(obj0, &val1);
28475 if (!SWIG_IsOK(ecode1)) {
28476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28477 }
28478 arg1 = static_cast< long >(val1);
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 wxPyApp::SetMacAboutMenuItemId(arg1);
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_Py_Void();
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28493 PyObject *resultobj = 0;
28494 long arg1 ;
28495 long val1 ;
28496 int ecode1 = 0 ;
28497 PyObject * obj0 = 0 ;
28498 char * kwnames[] = {
28499 (char *) "val", NULL
28500 };
28501
28502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28503 ecode1 = SWIG_AsVal_long(obj0, &val1);
28504 if (!SWIG_IsOK(ecode1)) {
28505 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28506 }
28507 arg1 = static_cast< long >(val1);
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28511 wxPyEndAllowThreads(__tstate);
28512 if (PyErr_Occurred()) SWIG_fail;
28513 }
28514 resultobj = SWIG_Py_Void();
28515 return resultobj;
28516 fail:
28517 return NULL;
28518 }
28519
28520
28521 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28522 PyObject *resultobj = 0;
28523 long arg1 ;
28524 long val1 ;
28525 int ecode1 = 0 ;
28526 PyObject * obj0 = 0 ;
28527 char * kwnames[] = {
28528 (char *) "val", NULL
28529 };
28530
28531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28532 ecode1 = SWIG_AsVal_long(obj0, &val1);
28533 if (!SWIG_IsOK(ecode1)) {
28534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28535 }
28536 arg1 = static_cast< long >(val1);
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 wxPyApp::SetMacExitMenuItemId(arg1);
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 resultobj = SWIG_Py_Void();
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28551 PyObject *resultobj = 0;
28552 wxString *arg1 = 0 ;
28553 bool temp1 = false ;
28554 PyObject * obj0 = 0 ;
28555 char * kwnames[] = {
28556 (char *) "val", NULL
28557 };
28558
28559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28560 {
28561 arg1 = wxString_in_helper(obj0);
28562 if (arg1 == NULL) SWIG_fail;
28563 temp1 = true;
28564 }
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 resultobj = SWIG_Py_Void();
28572 {
28573 if (temp1)
28574 delete arg1;
28575 }
28576 return resultobj;
28577 fail:
28578 {
28579 if (temp1)
28580 delete arg1;
28581 }
28582 return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28587 PyObject *resultobj = 0;
28588 wxPyApp *arg1 = (wxPyApp *) 0 ;
28589 void *argp1 = 0 ;
28590 int res1 = 0 ;
28591 PyObject *swig_obj[1] ;
28592
28593 if (!args) SWIG_fail;
28594 swig_obj[0] = args;
28595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28598 }
28599 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 (arg1)->_BootstrapApp();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 resultobj = SWIG_Py_Void();
28607 return resultobj;
28608 fail:
28609 return NULL;
28610 }
28611
28612
28613 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28614 PyObject *resultobj = 0;
28615 int result;
28616
28617 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28618 {
28619 PyThreadState* __tstate = wxPyBeginAllowThreads();
28620 result = (int)wxPyApp_GetComCtl32Version();
28621 wxPyEndAllowThreads(__tstate);
28622 if (PyErr_Occurred()) SWIG_fail;
28623 }
28624 resultobj = SWIG_From_int(static_cast< int >(result));
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *resultobj = 0;
28633 bool result;
28634
28635 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (bool)wxPyApp_IsDisplayAvailable();
28639 wxPyEndAllowThreads(__tstate);
28640 if (PyErr_Occurred()) SWIG_fail;
28641 }
28642 {
28643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28644 }
28645 return resultobj;
28646 fail:
28647 return NULL;
28648 }
28649
28650
28651 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28652 PyObject *obj;
28653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28654 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28655 return SWIG_Py_Void();
28656 }
28657
28658 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28659 return SWIG_Python_InitShadowInstance(args);
28660 }
28661
28662 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28663 PyObject *resultobj = 0;
28664
28665 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28666 {
28667 PyThreadState* __tstate = wxPyBeginAllowThreads();
28668 wxExit();
28669 wxPyEndAllowThreads(__tstate);
28670 if (PyErr_Occurred()) SWIG_fail;
28671 }
28672 resultobj = SWIG_Py_Void();
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28680 PyObject *resultobj = 0;
28681 bool result;
28682
28683 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28684 {
28685 PyThreadState* __tstate = wxPyBeginAllowThreads();
28686 result = (bool)wxYield();
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 {
28691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28692 }
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28700 PyObject *resultobj = 0;
28701 bool result;
28702
28703 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28704 {
28705 PyThreadState* __tstate = wxPyBeginAllowThreads();
28706 result = (bool)wxYieldIfNeeded();
28707 wxPyEndAllowThreads(__tstate);
28708 if (PyErr_Occurred()) SWIG_fail;
28709 }
28710 {
28711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28712 }
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28720 PyObject *resultobj = 0;
28721 wxWindow *arg1 = (wxWindow *) NULL ;
28722 bool arg2 = (bool) false ;
28723 bool result;
28724 void *argp1 = 0 ;
28725 int res1 = 0 ;
28726 bool val2 ;
28727 int ecode2 = 0 ;
28728 PyObject * obj0 = 0 ;
28729 PyObject * obj1 = 0 ;
28730 char * kwnames[] = {
28731 (char *) "win",(char *) "onlyIfNeeded", NULL
28732 };
28733
28734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28735 if (obj0) {
28736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28737 if (!SWIG_IsOK(res1)) {
28738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28739 }
28740 arg1 = reinterpret_cast< wxWindow * >(argp1);
28741 }
28742 if (obj1) {
28743 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28744 if (!SWIG_IsOK(ecode2)) {
28745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28746 }
28747 arg2 = static_cast< bool >(val2);
28748 }
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 result = (bool)wxSafeYield(arg1,arg2);
28752 wxPyEndAllowThreads(__tstate);
28753 if (PyErr_Occurred()) SWIG_fail;
28754 }
28755 {
28756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28757 }
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28765 PyObject *resultobj = 0;
28766
28767 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28768 {
28769 PyThreadState* __tstate = wxPyBeginAllowThreads();
28770 wxWakeUpIdle();
28771 wxPyEndAllowThreads(__tstate);
28772 if (PyErr_Occurred()) SWIG_fail;
28773 }
28774 resultobj = SWIG_Py_Void();
28775 return resultobj;
28776 fail:
28777 return NULL;
28778 }
28779
28780
28781 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28782 PyObject *resultobj = 0;
28783 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28784 wxEvent *arg2 = 0 ;
28785 void *argp1 = 0 ;
28786 int res1 = 0 ;
28787 void *argp2 = 0 ;
28788 int res2 = 0 ;
28789 PyObject * obj0 = 0 ;
28790 PyObject * obj1 = 0 ;
28791 char * kwnames[] = {
28792 (char *) "dest",(char *) "event", NULL
28793 };
28794
28795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28797 if (!SWIG_IsOK(res1)) {
28798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28799 }
28800 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28802 if (!SWIG_IsOK(res2)) {
28803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28804 }
28805 if (!argp2) {
28806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28807 }
28808 arg2 = reinterpret_cast< wxEvent * >(argp2);
28809 {
28810 PyThreadState* __tstate = wxPyBeginAllowThreads();
28811 wxPostEvent(arg1,*arg2);
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 resultobj = SWIG_Py_Void();
28816 return resultobj;
28817 fail:
28818 return NULL;
28819 }
28820
28821
28822 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28823 PyObject *resultobj = 0;
28824
28825 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 wxApp_CleanUp();
28829 wxPyEndAllowThreads(__tstate);
28830 if (PyErr_Occurred()) SWIG_fail;
28831 }
28832 resultobj = SWIG_Py_Void();
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28840 PyObject *resultobj = 0;
28841 wxPyApp *result = 0 ;
28842
28843 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28844 {
28845 PyThreadState* __tstate = wxPyBeginAllowThreads();
28846 result = (wxPyApp *)wxPyGetApp();
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 {
28851 resultobj = wxPyMake_wxObject(result, 0);
28852 }
28853 return resultobj;
28854 fail:
28855 return NULL;
28856 }
28857
28858
28859 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28860 PyObject *resultobj = 0;
28861 char *arg1 = (char *) 0 ;
28862 int res1 ;
28863 char *buf1 = 0 ;
28864 int alloc1 = 0 ;
28865 PyObject * obj0 = 0 ;
28866 char * kwnames[] = {
28867 (char *) "encoding", NULL
28868 };
28869
28870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28871 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28872 if (!SWIG_IsOK(res1)) {
28873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28874 }
28875 arg1 = buf1;
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 wxSetDefaultPyEncoding((char const *)arg1);
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_Py_Void();
28883 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28884 return resultobj;
28885 fail:
28886 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28887 return NULL;
28888 }
28889
28890
28891 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28892 PyObject *resultobj = 0;
28893 char *result = 0 ;
28894
28895 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 result = (char *)wxGetDefaultPyEncoding();
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 resultobj = SWIG_FromCharPtr(result);
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28910 PyObject *resultobj = 0;
28911 wxEventLoop *result = 0 ;
28912
28913 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 result = (wxEventLoop *)new wxEventLoop();
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28928 PyObject *resultobj = 0;
28929 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28930 void *argp1 = 0 ;
28931 int res1 = 0 ;
28932 PyObject *swig_obj[1] ;
28933
28934 if (!args) SWIG_fail;
28935 swig_obj[0] = args;
28936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28937 if (!SWIG_IsOK(res1)) {
28938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28939 }
28940 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 delete arg1;
28944
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 resultobj = SWIG_Py_Void();
28949 return resultobj;
28950 fail:
28951 return NULL;
28952 }
28953
28954
28955 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28956 PyObject *resultobj = 0;
28957 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28958 int result;
28959 void *argp1 = 0 ;
28960 int res1 = 0 ;
28961 PyObject *swig_obj[1] ;
28962
28963 if (!args) SWIG_fail;
28964 swig_obj[0] = args;
28965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28966 if (!SWIG_IsOK(res1)) {
28967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28968 }
28969 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (int)(arg1)->Run();
28973 wxPyEndAllowThreads(__tstate);
28974 if (PyErr_Occurred()) SWIG_fail;
28975 }
28976 resultobj = SWIG_From_int(static_cast< int >(result));
28977 return resultobj;
28978 fail:
28979 return NULL;
28980 }
28981
28982
28983 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj = 0;
28985 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28986 int arg2 = (int) 0 ;
28987 void *argp1 = 0 ;
28988 int res1 = 0 ;
28989 int val2 ;
28990 int ecode2 = 0 ;
28991 PyObject * obj0 = 0 ;
28992 PyObject * obj1 = 0 ;
28993 char * kwnames[] = {
28994 (char *) "self",(char *) "rc", NULL
28995 };
28996
28997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28999 if (!SWIG_IsOK(res1)) {
29000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29001 }
29002 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29003 if (obj1) {
29004 ecode2 = SWIG_AsVal_int(obj1, &val2);
29005 if (!SWIG_IsOK(ecode2)) {
29006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29007 }
29008 arg2 = static_cast< int >(val2);
29009 }
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 (arg1)->Exit(arg2);
29013 wxPyEndAllowThreads(__tstate);
29014 if (PyErr_Occurred()) SWIG_fail;
29015 }
29016 resultobj = SWIG_Py_Void();
29017 return resultobj;
29018 fail:
29019 return NULL;
29020 }
29021
29022
29023 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29024 PyObject *resultobj = 0;
29025 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29026 bool result;
29027 void *argp1 = 0 ;
29028 int res1 = 0 ;
29029 PyObject *swig_obj[1] ;
29030
29031 if (!args) SWIG_fail;
29032 swig_obj[0] = args;
29033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29034 if (!SWIG_IsOK(res1)) {
29035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29036 }
29037 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 result = (bool)((wxEventLoop const *)arg1)->Pending();
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 {
29045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29046 }
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29054 PyObject *resultobj = 0;
29055 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29056 bool result;
29057 void *argp1 = 0 ;
29058 int res1 = 0 ;
29059 PyObject *swig_obj[1] ;
29060
29061 if (!args) SWIG_fail;
29062 swig_obj[0] = args;
29063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29064 if (!SWIG_IsOK(res1)) {
29065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29066 }
29067 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 result = (bool)(arg1)->Dispatch();
29071 wxPyEndAllowThreads(__tstate);
29072 if (PyErr_Occurred()) SWIG_fail;
29073 }
29074 {
29075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29076 }
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29084 PyObject *resultobj = 0;
29085 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29086 bool result;
29087 void *argp1 = 0 ;
29088 int res1 = 0 ;
29089 PyObject *swig_obj[1] ;
29090
29091 if (!args) SWIG_fail;
29092 swig_obj[0] = args;
29093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29096 }
29097 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 {
29105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29106 }
29107 return resultobj;
29108 fail:
29109 return NULL;
29110 }
29111
29112
29113 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29114 PyObject *resultobj = 0;
29115 wxEventLoop *result = 0 ;
29116
29117 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29118 {
29119 PyThreadState* __tstate = wxPyBeginAllowThreads();
29120 result = (wxEventLoop *)wxEventLoop::GetActive();
29121 wxPyEndAllowThreads(__tstate);
29122 if (PyErr_Occurred()) SWIG_fail;
29123 }
29124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29125 return resultobj;
29126 fail:
29127 return NULL;
29128 }
29129
29130
29131 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29132 PyObject *resultobj = 0;
29133 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29134 void *argp1 = 0 ;
29135 int res1 = 0 ;
29136 PyObject * obj0 = 0 ;
29137 char * kwnames[] = {
29138 (char *) "loop", NULL
29139 };
29140
29141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29143 if (!SWIG_IsOK(res1)) {
29144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29145 }
29146 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 wxEventLoop::SetActive(arg1);
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 resultobj = SWIG_Py_Void();
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29161 PyObject *obj;
29162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29163 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29164 return SWIG_Py_Void();
29165 }
29166
29167 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29168 return SWIG_Python_InitShadowInstance(args);
29169 }
29170
29171 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29172 PyObject *resultobj = 0;
29173 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29174 wxEventLoopActivator *result = 0 ;
29175 void *argp1 = 0 ;
29176 int res1 = 0 ;
29177 PyObject * obj0 = 0 ;
29178 char * kwnames[] = {
29179 (char *) "evtLoop", NULL
29180 };
29181
29182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29184 if (!SWIG_IsOK(res1)) {
29185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29186 }
29187 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29188 {
29189 PyThreadState* __tstate = wxPyBeginAllowThreads();
29190 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29195 return resultobj;
29196 fail:
29197 return NULL;
29198 }
29199
29200
29201 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29202 PyObject *resultobj = 0;
29203 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29204 void *argp1 = 0 ;
29205 int res1 = 0 ;
29206 PyObject *swig_obj[1] ;
29207
29208 if (!args) SWIG_fail;
29209 swig_obj[0] = args;
29210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29211 if (!SWIG_IsOK(res1)) {
29212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29213 }
29214 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29215 {
29216 PyThreadState* __tstate = wxPyBeginAllowThreads();
29217 delete arg1;
29218
29219 wxPyEndAllowThreads(__tstate);
29220 if (PyErr_Occurred()) SWIG_fail;
29221 }
29222 resultobj = SWIG_Py_Void();
29223 return resultobj;
29224 fail:
29225 return NULL;
29226 }
29227
29228
29229 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29230 PyObject *obj;
29231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29232 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29233 return SWIG_Py_Void();
29234 }
29235
29236 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29237 return SWIG_Python_InitShadowInstance(args);
29238 }
29239
29240 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29241 PyObject *resultobj = 0;
29242 int arg1 = (int) 0 ;
29243 int arg2 = (int) 0 ;
29244 int arg3 = (int) 0 ;
29245 wxAcceleratorEntry *result = 0 ;
29246 int val1 ;
29247 int ecode1 = 0 ;
29248 int val2 ;
29249 int ecode2 = 0 ;
29250 int val3 ;
29251 int ecode3 = 0 ;
29252 PyObject * obj0 = 0 ;
29253 PyObject * obj1 = 0 ;
29254 PyObject * obj2 = 0 ;
29255 char * kwnames[] = {
29256 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29257 };
29258
29259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29260 if (obj0) {
29261 ecode1 = SWIG_AsVal_int(obj0, &val1);
29262 if (!SWIG_IsOK(ecode1)) {
29263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29264 }
29265 arg1 = static_cast< int >(val1);
29266 }
29267 if (obj1) {
29268 ecode2 = SWIG_AsVal_int(obj1, &val2);
29269 if (!SWIG_IsOK(ecode2)) {
29270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29271 }
29272 arg2 = static_cast< int >(val2);
29273 }
29274 if (obj2) {
29275 ecode3 = SWIG_AsVal_int(obj2, &val3);
29276 if (!SWIG_IsOK(ecode3)) {
29277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29278 }
29279 arg3 = static_cast< int >(val3);
29280 }
29281 {
29282 PyThreadState* __tstate = wxPyBeginAllowThreads();
29283 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29284 wxPyEndAllowThreads(__tstate);
29285 if (PyErr_Occurred()) SWIG_fail;
29286 }
29287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29288 return resultobj;
29289 fail:
29290 return NULL;
29291 }
29292
29293
29294 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29295 PyObject *resultobj = 0;
29296 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29297 void *argp1 = 0 ;
29298 int res1 = 0 ;
29299 PyObject *swig_obj[1] ;
29300
29301 if (!args) SWIG_fail;
29302 swig_obj[0] = args;
29303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29304 if (!SWIG_IsOK(res1)) {
29305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29306 }
29307 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 delete arg1;
29311
29312 wxPyEndAllowThreads(__tstate);
29313 if (PyErr_Occurred()) SWIG_fail;
29314 }
29315 resultobj = SWIG_Py_Void();
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj = 0;
29324 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29325 int arg2 ;
29326 int arg3 ;
29327 int arg4 ;
29328 void *argp1 = 0 ;
29329 int res1 = 0 ;
29330 int val2 ;
29331 int ecode2 = 0 ;
29332 int val3 ;
29333 int ecode3 = 0 ;
29334 int val4 ;
29335 int ecode4 = 0 ;
29336 PyObject * obj0 = 0 ;
29337 PyObject * obj1 = 0 ;
29338 PyObject * obj2 = 0 ;
29339 PyObject * obj3 = 0 ;
29340 char * kwnames[] = {
29341 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29342 };
29343
29344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29346 if (!SWIG_IsOK(res1)) {
29347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29348 }
29349 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29350 ecode2 = SWIG_AsVal_int(obj1, &val2);
29351 if (!SWIG_IsOK(ecode2)) {
29352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29353 }
29354 arg2 = static_cast< int >(val2);
29355 ecode3 = SWIG_AsVal_int(obj2, &val3);
29356 if (!SWIG_IsOK(ecode3)) {
29357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29358 }
29359 arg3 = static_cast< int >(val3);
29360 ecode4 = SWIG_AsVal_int(obj3, &val4);
29361 if (!SWIG_IsOK(ecode4)) {
29362 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29363 }
29364 arg4 = static_cast< int >(val4);
29365 {
29366 PyThreadState* __tstate = wxPyBeginAllowThreads();
29367 (arg1)->Set(arg2,arg3,arg4);
29368 wxPyEndAllowThreads(__tstate);
29369 if (PyErr_Occurred()) SWIG_fail;
29370 }
29371 resultobj = SWIG_Py_Void();
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj = 0;
29380 wxString *arg1 = 0 ;
29381 wxAcceleratorEntry *result = 0 ;
29382 bool temp1 = false ;
29383 PyObject * obj0 = 0 ;
29384 char * kwnames[] = {
29385 (char *) "str", NULL
29386 };
29387
29388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29389 {
29390 arg1 = wxString_in_helper(obj0);
29391 if (arg1 == NULL) SWIG_fail;
29392 temp1 = true;
29393 }
29394 {
29395 PyThreadState* __tstate = wxPyBeginAllowThreads();
29396 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29401 {
29402 if (temp1)
29403 delete arg1;
29404 }
29405 return resultobj;
29406 fail:
29407 {
29408 if (temp1)
29409 delete arg1;
29410 }
29411 return NULL;
29412 }
29413
29414
29415 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 PyObject *resultobj = 0;
29417 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29418 int result;
29419 void *argp1 = 0 ;
29420 int res1 = 0 ;
29421 PyObject *swig_obj[1] ;
29422
29423 if (!args) SWIG_fail;
29424 swig_obj[0] = args;
29425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29428 }
29429 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (int)(arg1)->GetFlags();
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 resultobj = SWIG_From_int(static_cast< int >(result));
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29444 PyObject *resultobj = 0;
29445 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29446 int result;
29447 void *argp1 = 0 ;
29448 int res1 = 0 ;
29449 PyObject *swig_obj[1] ;
29450
29451 if (!args) SWIG_fail;
29452 swig_obj[0] = args;
29453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29454 if (!SWIG_IsOK(res1)) {
29455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29456 }
29457 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 result = (int)(arg1)->GetKeyCode();
29461 wxPyEndAllowThreads(__tstate);
29462 if (PyErr_Occurred()) SWIG_fail;
29463 }
29464 resultobj = SWIG_From_int(static_cast< int >(result));
29465 return resultobj;
29466 fail:
29467 return NULL;
29468 }
29469
29470
29471 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29472 PyObject *resultobj = 0;
29473 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29474 int result;
29475 void *argp1 = 0 ;
29476 int res1 = 0 ;
29477 PyObject *swig_obj[1] ;
29478
29479 if (!args) SWIG_fail;
29480 swig_obj[0] = args;
29481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29482 if (!SWIG_IsOK(res1)) {
29483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29484 }
29485 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29486 {
29487 PyThreadState* __tstate = wxPyBeginAllowThreads();
29488 result = (int)(arg1)->GetCommand();
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 resultobj = SWIG_From_int(static_cast< int >(result));
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29500 PyObject *resultobj = 0;
29501 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29502 bool result;
29503 void *argp1 = 0 ;
29504 int res1 = 0 ;
29505 PyObject *swig_obj[1] ;
29506
29507 if (!args) SWIG_fail;
29508 swig_obj[0] = args;
29509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29510 if (!SWIG_IsOK(res1)) {
29511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29512 }
29513 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 {
29521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29522 }
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29530 PyObject *resultobj = 0;
29531 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29532 wxString result;
29533 void *argp1 = 0 ;
29534 int res1 = 0 ;
29535 PyObject *swig_obj[1] ;
29536
29537 if (!args) SWIG_fail;
29538 swig_obj[0] = args;
29539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29540 if (!SWIG_IsOK(res1)) {
29541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29542 }
29543 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29544 {
29545 PyThreadState* __tstate = wxPyBeginAllowThreads();
29546 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29547 wxPyEndAllowThreads(__tstate);
29548 if (PyErr_Occurred()) SWIG_fail;
29549 }
29550 {
29551 #if wxUSE_UNICODE
29552 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29553 #else
29554 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29555 #endif
29556 }
29557 return resultobj;
29558 fail:
29559 return NULL;
29560 }
29561
29562
29563 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29564 PyObject *resultobj = 0;
29565 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29566 wxString *arg2 = 0 ;
29567 bool result;
29568 void *argp1 = 0 ;
29569 int res1 = 0 ;
29570 bool temp2 = false ;
29571 PyObject * obj0 = 0 ;
29572 PyObject * obj1 = 0 ;
29573 char * kwnames[] = {
29574 (char *) "self",(char *) "str", NULL
29575 };
29576
29577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29579 if (!SWIG_IsOK(res1)) {
29580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29581 }
29582 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29583 {
29584 arg2 = wxString_in_helper(obj1);
29585 if (arg2 == NULL) SWIG_fail;
29586 temp2 = true;
29587 }
29588 {
29589 PyThreadState* __tstate = wxPyBeginAllowThreads();
29590 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29591 wxPyEndAllowThreads(__tstate);
29592 if (PyErr_Occurred()) SWIG_fail;
29593 }
29594 {
29595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29596 }
29597 {
29598 if (temp2)
29599 delete arg2;
29600 }
29601 return resultobj;
29602 fail:
29603 {
29604 if (temp2)
29605 delete arg2;
29606 }
29607 return NULL;
29608 }
29609
29610
29611 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29612 PyObject *obj;
29613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29614 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29615 return SWIG_Py_Void();
29616 }
29617
29618 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29619 return SWIG_Python_InitShadowInstance(args);
29620 }
29621
29622 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29623 PyObject *resultobj = 0;
29624 int arg1 ;
29625 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29626 wxAcceleratorTable *result = 0 ;
29627 PyObject * obj0 = 0 ;
29628 char * kwnames[] = {
29629 (char *) "n", NULL
29630 };
29631
29632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29633 {
29634 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29635 if (arg2) arg1 = PyList_Size(obj0);
29636 else arg1 = 0;
29637 }
29638 {
29639 PyThreadState* __tstate = wxPyBeginAllowThreads();
29640 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29641 wxPyEndAllowThreads(__tstate);
29642 if (PyErr_Occurred()) SWIG_fail;
29643 }
29644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29645 return resultobj;
29646 fail:
29647 return NULL;
29648 }
29649
29650
29651 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29652 PyObject *resultobj = 0;
29653 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29654 void *argp1 = 0 ;
29655 int res1 = 0 ;
29656 PyObject *swig_obj[1] ;
29657
29658 if (!args) SWIG_fail;
29659 swig_obj[0] = args;
29660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29661 if (!SWIG_IsOK(res1)) {
29662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29663 }
29664 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29665 {
29666 PyThreadState* __tstate = wxPyBeginAllowThreads();
29667 delete arg1;
29668
29669 wxPyEndAllowThreads(__tstate);
29670 if (PyErr_Occurred()) SWIG_fail;
29671 }
29672 resultobj = SWIG_Py_Void();
29673 return resultobj;
29674 fail:
29675 return NULL;
29676 }
29677
29678
29679 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29680 PyObject *resultobj = 0;
29681 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29682 bool result;
29683 void *argp1 = 0 ;
29684 int res1 = 0 ;
29685 PyObject *swig_obj[1] ;
29686
29687 if (!args) SWIG_fail;
29688 swig_obj[0] = args;
29689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29690 if (!SWIG_IsOK(res1)) {
29691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29692 }
29693 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29702 }
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29710 PyObject *obj;
29711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29712 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29713 return SWIG_Py_Void();
29714 }
29715
29716 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29717 return SWIG_Python_InitShadowInstance(args);
29718 }
29719
29720 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29721 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29722 return 1;
29723 }
29724
29725
29726 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29727 PyObject *pyobj = 0;
29728
29729 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29730 return pyobj;
29731 }
29732
29733
29734 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29735 PyObject *resultobj = 0;
29736 wxString *arg1 = 0 ;
29737 wxAcceleratorEntry *result = 0 ;
29738 bool temp1 = false ;
29739 PyObject * obj0 = 0 ;
29740 char * kwnames[] = {
29741 (char *) "label", NULL
29742 };
29743
29744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29745 {
29746 arg1 = wxString_in_helper(obj0);
29747 if (arg1 == NULL) SWIG_fail;
29748 temp1 = true;
29749 }
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29757 {
29758 if (temp1)
29759 delete arg1;
29760 }
29761 return resultobj;
29762 fail:
29763 {
29764 if (temp1)
29765 delete arg1;
29766 }
29767 return NULL;
29768 }
29769
29770
29771 SWIGINTERN int PanelNameStr_set(PyObject *) {
29772 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29773 return 1;
29774 }
29775
29776
29777 SWIGINTERN PyObject *PanelNameStr_get(void) {
29778 PyObject *pyobj = 0;
29779
29780 {
29781 #if wxUSE_UNICODE
29782 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29783 #else
29784 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29785 #endif
29786 }
29787 return pyobj;
29788 }
29789
29790
29791 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29792 PyObject *resultobj = 0;
29793 wxVisualAttributes *result = 0 ;
29794
29795 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29796 {
29797 PyThreadState* __tstate = wxPyBeginAllowThreads();
29798 result = (wxVisualAttributes *)new_wxVisualAttributes();
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29810 PyObject *resultobj = 0;
29811 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29812 void *argp1 = 0 ;
29813 int res1 = 0 ;
29814 PyObject *swig_obj[1] ;
29815
29816 if (!args) SWIG_fail;
29817 swig_obj[0] = args;
29818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29819 if (!SWIG_IsOK(res1)) {
29820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29821 }
29822 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 delete_wxVisualAttributes(arg1);
29826
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 resultobj = SWIG_Py_Void();
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29838 PyObject *resultobj = 0;
29839 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29840 wxFont *arg2 = (wxFont *) 0 ;
29841 void *argp1 = 0 ;
29842 int res1 = 0 ;
29843 void *argp2 = 0 ;
29844 int res2 = 0 ;
29845 PyObject *swig_obj[2] ;
29846
29847 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29849 if (!SWIG_IsOK(res1)) {
29850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29851 }
29852 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29853 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29854 if (!SWIG_IsOK(res2)) {
29855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29856 }
29857 arg2 = reinterpret_cast< wxFont * >(argp2);
29858 if (arg1) (arg1)->font = *arg2;
29859
29860 resultobj = SWIG_Py_Void();
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29868 PyObject *resultobj = 0;
29869 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29870 wxFont *result = 0 ;
29871 void *argp1 = 0 ;
29872 int res1 = 0 ;
29873 PyObject *swig_obj[1] ;
29874
29875 if (!args) SWIG_fail;
29876 swig_obj[0] = args;
29877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29878 if (!SWIG_IsOK(res1)) {
29879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29880 }
29881 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29882 result = (wxFont *)& ((arg1)->font);
29883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29891 PyObject *resultobj = 0;
29892 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29893 wxColour *arg2 = (wxColour *) 0 ;
29894 void *argp1 = 0 ;
29895 int res1 = 0 ;
29896 void *argp2 = 0 ;
29897 int res2 = 0 ;
29898 PyObject *swig_obj[2] ;
29899
29900 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29904 }
29905 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29906 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29907 if (!SWIG_IsOK(res2)) {
29908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29909 }
29910 arg2 = reinterpret_cast< wxColour * >(argp2);
29911 if (arg1) (arg1)->colFg = *arg2;
29912
29913 resultobj = SWIG_Py_Void();
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29921 PyObject *resultobj = 0;
29922 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29923 wxColour *result = 0 ;
29924 void *argp1 = 0 ;
29925 int res1 = 0 ;
29926 PyObject *swig_obj[1] ;
29927
29928 if (!args) SWIG_fail;
29929 swig_obj[0] = args;
29930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29931 if (!SWIG_IsOK(res1)) {
29932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29933 }
29934 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29935 result = (wxColour *)& ((arg1)->colFg);
29936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29944 PyObject *resultobj = 0;
29945 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29946 wxColour *arg2 = (wxColour *) 0 ;
29947 void *argp1 = 0 ;
29948 int res1 = 0 ;
29949 void *argp2 = 0 ;
29950 int res2 = 0 ;
29951 PyObject *swig_obj[2] ;
29952
29953 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29955 if (!SWIG_IsOK(res1)) {
29956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29957 }
29958 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29959 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29960 if (!SWIG_IsOK(res2)) {
29961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29962 }
29963 arg2 = reinterpret_cast< wxColour * >(argp2);
29964 if (arg1) (arg1)->colBg = *arg2;
29965
29966 resultobj = SWIG_Py_Void();
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29974 PyObject *resultobj = 0;
29975 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29976 wxColour *result = 0 ;
29977 void *argp1 = 0 ;
29978 int res1 = 0 ;
29979 PyObject *swig_obj[1] ;
29980
29981 if (!args) SWIG_fail;
29982 swig_obj[0] = args;
29983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29986 }
29987 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29988 result = (wxColour *)& ((arg1)->colBg);
29989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29997 PyObject *obj;
29998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29999 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30000 return SWIG_Py_Void();
30001 }
30002
30003 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30004 return SWIG_Python_InitShadowInstance(args);
30005 }
30006
30007 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj = 0;
30009 wxWindow *arg1 = (wxWindow *) 0 ;
30010 int arg2 = (int) (int)-1 ;
30011 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30012 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30013 wxSize const &arg4_defvalue = wxDefaultSize ;
30014 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30015 long arg5 = (long) 0 ;
30016 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30017 wxString *arg6 = (wxString *) &arg6_defvalue ;
30018 wxWindow *result = 0 ;
30019 void *argp1 = 0 ;
30020 int res1 = 0 ;
30021 int val2 ;
30022 int ecode2 = 0 ;
30023 wxPoint temp3 ;
30024 wxSize temp4 ;
30025 long val5 ;
30026 int ecode5 = 0 ;
30027 bool temp6 = false ;
30028 PyObject * obj0 = 0 ;
30029 PyObject * obj1 = 0 ;
30030 PyObject * obj2 = 0 ;
30031 PyObject * obj3 = 0 ;
30032 PyObject * obj4 = 0 ;
30033 PyObject * obj5 = 0 ;
30034 char * kwnames[] = {
30035 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30036 };
30037
30038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30040 if (!SWIG_IsOK(res1)) {
30041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30042 }
30043 arg1 = reinterpret_cast< wxWindow * >(argp1);
30044 if (obj1) {
30045 ecode2 = SWIG_AsVal_int(obj1, &val2);
30046 if (!SWIG_IsOK(ecode2)) {
30047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30048 }
30049 arg2 = static_cast< int >(val2);
30050 }
30051 if (obj2) {
30052 {
30053 arg3 = &temp3;
30054 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30055 }
30056 }
30057 if (obj3) {
30058 {
30059 arg4 = &temp4;
30060 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30061 }
30062 }
30063 if (obj4) {
30064 ecode5 = SWIG_AsVal_long(obj4, &val5);
30065 if (!SWIG_IsOK(ecode5)) {
30066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30067 }
30068 arg5 = static_cast< long >(val5);
30069 }
30070 if (obj5) {
30071 {
30072 arg6 = wxString_in_helper(obj5);
30073 if (arg6 == NULL) SWIG_fail;
30074 temp6 = true;
30075 }
30076 }
30077 {
30078 if (!wxPyCheckForApp()) SWIG_fail;
30079 PyThreadState* __tstate = wxPyBeginAllowThreads();
30080 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30081 wxPyEndAllowThreads(__tstate);
30082 if (PyErr_Occurred()) SWIG_fail;
30083 }
30084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30085 {
30086 if (temp6)
30087 delete arg6;
30088 }
30089 return resultobj;
30090 fail:
30091 {
30092 if (temp6)
30093 delete arg6;
30094 }
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *resultobj = 0;
30101 wxWindow *result = 0 ;
30102
30103 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30104 {
30105 if (!wxPyCheckForApp()) SWIG_fail;
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 result = (wxWindow *)new wxWindow();
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj = 0;
30120 wxWindow *arg1 = (wxWindow *) 0 ;
30121 wxWindow *arg2 = (wxWindow *) 0 ;
30122 int arg3 = (int) (int)-1 ;
30123 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30124 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30125 wxSize const &arg5_defvalue = wxDefaultSize ;
30126 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30127 long arg6 = (long) 0 ;
30128 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30129 wxString *arg7 = (wxString *) &arg7_defvalue ;
30130 bool result;
30131 void *argp1 = 0 ;
30132 int res1 = 0 ;
30133 void *argp2 = 0 ;
30134 int res2 = 0 ;
30135 int val3 ;
30136 int ecode3 = 0 ;
30137 wxPoint temp4 ;
30138 wxSize temp5 ;
30139 long val6 ;
30140 int ecode6 = 0 ;
30141 bool temp7 = false ;
30142 PyObject * obj0 = 0 ;
30143 PyObject * obj1 = 0 ;
30144 PyObject * obj2 = 0 ;
30145 PyObject * obj3 = 0 ;
30146 PyObject * obj4 = 0 ;
30147 PyObject * obj5 = 0 ;
30148 PyObject * obj6 = 0 ;
30149 char * kwnames[] = {
30150 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30151 };
30152
30153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30155 if (!SWIG_IsOK(res1)) {
30156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30157 }
30158 arg1 = reinterpret_cast< wxWindow * >(argp1);
30159 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30160 if (!SWIG_IsOK(res2)) {
30161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30162 }
30163 arg2 = reinterpret_cast< wxWindow * >(argp2);
30164 if (obj2) {
30165 ecode3 = SWIG_AsVal_int(obj2, &val3);
30166 if (!SWIG_IsOK(ecode3)) {
30167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30168 }
30169 arg3 = static_cast< int >(val3);
30170 }
30171 if (obj3) {
30172 {
30173 arg4 = &temp4;
30174 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30175 }
30176 }
30177 if (obj4) {
30178 {
30179 arg5 = &temp5;
30180 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30181 }
30182 }
30183 if (obj5) {
30184 ecode6 = SWIG_AsVal_long(obj5, &val6);
30185 if (!SWIG_IsOK(ecode6)) {
30186 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30187 }
30188 arg6 = static_cast< long >(val6);
30189 }
30190 if (obj6) {
30191 {
30192 arg7 = wxString_in_helper(obj6);
30193 if (arg7 == NULL) SWIG_fail;
30194 temp7 = true;
30195 }
30196 }
30197 {
30198 PyThreadState* __tstate = wxPyBeginAllowThreads();
30199 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30200 wxPyEndAllowThreads(__tstate);
30201 if (PyErr_Occurred()) SWIG_fail;
30202 }
30203 {
30204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30205 }
30206 {
30207 if (temp7)
30208 delete arg7;
30209 }
30210 return resultobj;
30211 fail:
30212 {
30213 if (temp7)
30214 delete arg7;
30215 }
30216 return NULL;
30217 }
30218
30219
30220 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30221 PyObject *resultobj = 0;
30222 wxWindow *arg1 = (wxWindow *) 0 ;
30223 bool arg2 = (bool) false ;
30224 bool result;
30225 void *argp1 = 0 ;
30226 int res1 = 0 ;
30227 bool val2 ;
30228 int ecode2 = 0 ;
30229 PyObject * obj0 = 0 ;
30230 PyObject * obj1 = 0 ;
30231 char * kwnames[] = {
30232 (char *) "self",(char *) "force", NULL
30233 };
30234
30235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30237 if (!SWIG_IsOK(res1)) {
30238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30239 }
30240 arg1 = reinterpret_cast< wxWindow * >(argp1);
30241 if (obj1) {
30242 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30243 if (!SWIG_IsOK(ecode2)) {
30244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30245 }
30246 arg2 = static_cast< bool >(val2);
30247 }
30248 {
30249 PyThreadState* __tstate = wxPyBeginAllowThreads();
30250 result = (bool)(arg1)->Close(arg2);
30251 wxPyEndAllowThreads(__tstate);
30252 if (PyErr_Occurred()) SWIG_fail;
30253 }
30254 {
30255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30256 }
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30264 PyObject *resultobj = 0;
30265 wxWindow *arg1 = (wxWindow *) 0 ;
30266 bool result;
30267 void *argp1 = 0 ;
30268 int res1 = 0 ;
30269 PyObject *swig_obj[1] ;
30270
30271 if (!args) SWIG_fail;
30272 swig_obj[0] = args;
30273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30274 if (!SWIG_IsOK(res1)) {
30275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30276 }
30277 arg1 = reinterpret_cast< wxWindow * >(argp1);
30278 {
30279 PyThreadState* __tstate = wxPyBeginAllowThreads();
30280 result = (bool)(arg1)->Destroy();
30281 wxPyEndAllowThreads(__tstate);
30282 if (PyErr_Occurred()) SWIG_fail;
30283 }
30284 {
30285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30286 }
30287 return resultobj;
30288 fail:
30289 return NULL;
30290 }
30291
30292
30293 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30294 PyObject *resultobj = 0;
30295 wxWindow *arg1 = (wxWindow *) 0 ;
30296 bool result;
30297 void *argp1 = 0 ;
30298 int res1 = 0 ;
30299 PyObject *swig_obj[1] ;
30300
30301 if (!args) SWIG_fail;
30302 swig_obj[0] = args;
30303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30304 if (!SWIG_IsOK(res1)) {
30305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30306 }
30307 arg1 = reinterpret_cast< wxWindow * >(argp1);
30308 {
30309 PyThreadState* __tstate = wxPyBeginAllowThreads();
30310 result = (bool)(arg1)->DestroyChildren();
30311 wxPyEndAllowThreads(__tstate);
30312 if (PyErr_Occurred()) SWIG_fail;
30313 }
30314 {
30315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30316 }
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30324 PyObject *resultobj = 0;
30325 wxWindow *arg1 = (wxWindow *) 0 ;
30326 bool result;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 PyObject *swig_obj[1] ;
30330
30331 if (!args) SWIG_fail;
30332 swig_obj[0] = args;
30333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30334 if (!SWIG_IsOK(res1)) {
30335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30336 }
30337 arg1 = reinterpret_cast< wxWindow * >(argp1);
30338 {
30339 PyThreadState* __tstate = wxPyBeginAllowThreads();
30340 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30341 wxPyEndAllowThreads(__tstate);
30342 if (PyErr_Occurred()) SWIG_fail;
30343 }
30344 {
30345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30346 }
30347 return resultobj;
30348 fail:
30349 return NULL;
30350 }
30351
30352
30353 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30354 PyObject *resultobj = 0;
30355 wxWindow *arg1 = (wxWindow *) 0 ;
30356 wxString *arg2 = 0 ;
30357 void *argp1 = 0 ;
30358 int res1 = 0 ;
30359 bool temp2 = false ;
30360 PyObject * obj0 = 0 ;
30361 PyObject * obj1 = 0 ;
30362 char * kwnames[] = {
30363 (char *) "self",(char *) "label", NULL
30364 };
30365
30366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30368 if (!SWIG_IsOK(res1)) {
30369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30370 }
30371 arg1 = reinterpret_cast< wxWindow * >(argp1);
30372 {
30373 arg2 = wxString_in_helper(obj1);
30374 if (arg2 == NULL) SWIG_fail;
30375 temp2 = true;
30376 }
30377 {
30378 PyThreadState* __tstate = wxPyBeginAllowThreads();
30379 (arg1)->SetLabel((wxString const &)*arg2);
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 resultobj = SWIG_Py_Void();
30384 {
30385 if (temp2)
30386 delete arg2;
30387 }
30388 return resultobj;
30389 fail:
30390 {
30391 if (temp2)
30392 delete arg2;
30393 }
30394 return NULL;
30395 }
30396
30397
30398 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30399 PyObject *resultobj = 0;
30400 wxWindow *arg1 = (wxWindow *) 0 ;
30401 wxString result;
30402 void *argp1 = 0 ;
30403 int res1 = 0 ;
30404 PyObject *swig_obj[1] ;
30405
30406 if (!args) SWIG_fail;
30407 swig_obj[0] = args;
30408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30409 if (!SWIG_IsOK(res1)) {
30410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30411 }
30412 arg1 = reinterpret_cast< wxWindow * >(argp1);
30413 {
30414 PyThreadState* __tstate = wxPyBeginAllowThreads();
30415 result = ((wxWindow const *)arg1)->GetLabel();
30416 wxPyEndAllowThreads(__tstate);
30417 if (PyErr_Occurred()) SWIG_fail;
30418 }
30419 {
30420 #if wxUSE_UNICODE
30421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30422 #else
30423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30424 #endif
30425 }
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj = 0;
30434 wxWindow *arg1 = (wxWindow *) 0 ;
30435 wxString *arg2 = 0 ;
30436 void *argp1 = 0 ;
30437 int res1 = 0 ;
30438 bool temp2 = false ;
30439 PyObject * obj0 = 0 ;
30440 PyObject * obj1 = 0 ;
30441 char * kwnames[] = {
30442 (char *) "self",(char *) "name", NULL
30443 };
30444
30445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30447 if (!SWIG_IsOK(res1)) {
30448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30449 }
30450 arg1 = reinterpret_cast< wxWindow * >(argp1);
30451 {
30452 arg2 = wxString_in_helper(obj1);
30453 if (arg2 == NULL) SWIG_fail;
30454 temp2 = true;
30455 }
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 (arg1)->SetName((wxString const &)*arg2);
30459 wxPyEndAllowThreads(__tstate);
30460 if (PyErr_Occurred()) SWIG_fail;
30461 }
30462 resultobj = SWIG_Py_Void();
30463 {
30464 if (temp2)
30465 delete arg2;
30466 }
30467 return resultobj;
30468 fail:
30469 {
30470 if (temp2)
30471 delete arg2;
30472 }
30473 return NULL;
30474 }
30475
30476
30477 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30478 PyObject *resultobj = 0;
30479 wxWindow *arg1 = (wxWindow *) 0 ;
30480 wxString result;
30481 void *argp1 = 0 ;
30482 int res1 = 0 ;
30483 PyObject *swig_obj[1] ;
30484
30485 if (!args) SWIG_fail;
30486 swig_obj[0] = args;
30487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30488 if (!SWIG_IsOK(res1)) {
30489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30490 }
30491 arg1 = reinterpret_cast< wxWindow * >(argp1);
30492 {
30493 PyThreadState* __tstate = wxPyBeginAllowThreads();
30494 result = ((wxWindow const *)arg1)->GetName();
30495 wxPyEndAllowThreads(__tstate);
30496 if (PyErr_Occurred()) SWIG_fail;
30497 }
30498 {
30499 #if wxUSE_UNICODE
30500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30501 #else
30502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30503 #endif
30504 }
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30512 PyObject *resultobj = 0;
30513 wxWindow *arg1 = (wxWindow *) 0 ;
30514 wxWindowVariant arg2 ;
30515 void *argp1 = 0 ;
30516 int res1 = 0 ;
30517 int val2 ;
30518 int ecode2 = 0 ;
30519 PyObject * obj0 = 0 ;
30520 PyObject * obj1 = 0 ;
30521 char * kwnames[] = {
30522 (char *) "self",(char *) "variant", NULL
30523 };
30524
30525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30527 if (!SWIG_IsOK(res1)) {
30528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30529 }
30530 arg1 = reinterpret_cast< wxWindow * >(argp1);
30531 ecode2 = SWIG_AsVal_int(obj1, &val2);
30532 if (!SWIG_IsOK(ecode2)) {
30533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30534 }
30535 arg2 = static_cast< wxWindowVariant >(val2);
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 (arg1)->SetWindowVariant(arg2);
30539 wxPyEndAllowThreads(__tstate);
30540 if (PyErr_Occurred()) SWIG_fail;
30541 }
30542 resultobj = SWIG_Py_Void();
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30550 PyObject *resultobj = 0;
30551 wxWindow *arg1 = (wxWindow *) 0 ;
30552 wxWindowVariant result;
30553 void *argp1 = 0 ;
30554 int res1 = 0 ;
30555 PyObject *swig_obj[1] ;
30556
30557 if (!args) SWIG_fail;
30558 swig_obj[0] = args;
30559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30560 if (!SWIG_IsOK(res1)) {
30561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30562 }
30563 arg1 = reinterpret_cast< wxWindow * >(argp1);
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30567 wxPyEndAllowThreads(__tstate);
30568 if (PyErr_Occurred()) SWIG_fail;
30569 }
30570 resultobj = SWIG_From_int(static_cast< int >(result));
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30578 PyObject *resultobj = 0;
30579 wxWindow *arg1 = (wxWindow *) 0 ;
30580 int arg2 ;
30581 void *argp1 = 0 ;
30582 int res1 = 0 ;
30583 int val2 ;
30584 int ecode2 = 0 ;
30585 PyObject * obj0 = 0 ;
30586 PyObject * obj1 = 0 ;
30587 char * kwnames[] = {
30588 (char *) "self",(char *) "winid", NULL
30589 };
30590
30591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30593 if (!SWIG_IsOK(res1)) {
30594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30595 }
30596 arg1 = reinterpret_cast< wxWindow * >(argp1);
30597 ecode2 = SWIG_AsVal_int(obj1, &val2);
30598 if (!SWIG_IsOK(ecode2)) {
30599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30600 }
30601 arg2 = static_cast< int >(val2);
30602 {
30603 PyThreadState* __tstate = wxPyBeginAllowThreads();
30604 (arg1)->SetId(arg2);
30605 wxPyEndAllowThreads(__tstate);
30606 if (PyErr_Occurred()) SWIG_fail;
30607 }
30608 resultobj = SWIG_Py_Void();
30609 return resultobj;
30610 fail:
30611 return NULL;
30612 }
30613
30614
30615 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30616 PyObject *resultobj = 0;
30617 wxWindow *arg1 = (wxWindow *) 0 ;
30618 int result;
30619 void *argp1 = 0 ;
30620 int res1 = 0 ;
30621 PyObject *swig_obj[1] ;
30622
30623 if (!args) SWIG_fail;
30624 swig_obj[0] = args;
30625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30626 if (!SWIG_IsOK(res1)) {
30627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30628 }
30629 arg1 = reinterpret_cast< wxWindow * >(argp1);
30630 {
30631 PyThreadState* __tstate = wxPyBeginAllowThreads();
30632 result = (int)((wxWindow const *)arg1)->GetId();
30633 wxPyEndAllowThreads(__tstate);
30634 if (PyErr_Occurred()) SWIG_fail;
30635 }
30636 resultobj = SWIG_From_int(static_cast< int >(result));
30637 return resultobj;
30638 fail:
30639 return NULL;
30640 }
30641
30642
30643 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30644 PyObject *resultobj = 0;
30645 int result;
30646
30647 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 result = (int)wxWindow::NewControlId();
30651 wxPyEndAllowThreads(__tstate);
30652 if (PyErr_Occurred()) SWIG_fail;
30653 }
30654 resultobj = SWIG_From_int(static_cast< int >(result));
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30662 PyObject *resultobj = 0;
30663 int arg1 ;
30664 int result;
30665 int val1 ;
30666 int ecode1 = 0 ;
30667 PyObject * obj0 = 0 ;
30668 char * kwnames[] = {
30669 (char *) "winid", NULL
30670 };
30671
30672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30673 ecode1 = SWIG_AsVal_int(obj0, &val1);
30674 if (!SWIG_IsOK(ecode1)) {
30675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30676 }
30677 arg1 = static_cast< int >(val1);
30678 {
30679 PyThreadState* __tstate = wxPyBeginAllowThreads();
30680 result = (int)wxWindow::NextControlId(arg1);
30681 wxPyEndAllowThreads(__tstate);
30682 if (PyErr_Occurred()) SWIG_fail;
30683 }
30684 resultobj = SWIG_From_int(static_cast< int >(result));
30685 return resultobj;
30686 fail:
30687 return NULL;
30688 }
30689
30690
30691 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30692 PyObject *resultobj = 0;
30693 int arg1 ;
30694 int result;
30695 int val1 ;
30696 int ecode1 = 0 ;
30697 PyObject * obj0 = 0 ;
30698 char * kwnames[] = {
30699 (char *) "winid", NULL
30700 };
30701
30702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30703 ecode1 = SWIG_AsVal_int(obj0, &val1);
30704 if (!SWIG_IsOK(ecode1)) {
30705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30706 }
30707 arg1 = static_cast< int >(val1);
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 result = (int)wxWindow::PrevControlId(arg1);
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 resultobj = SWIG_From_int(static_cast< int >(result));
30715 return resultobj;
30716 fail:
30717 return NULL;
30718 }
30719
30720
30721 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30722 PyObject *resultobj = 0;
30723 wxWindow *arg1 = (wxWindow *) 0 ;
30724 wxLayoutDirection result;
30725 void *argp1 = 0 ;
30726 int res1 = 0 ;
30727 PyObject *swig_obj[1] ;
30728
30729 if (!args) SWIG_fail;
30730 swig_obj[0] = args;
30731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30732 if (!SWIG_IsOK(res1)) {
30733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30734 }
30735 arg1 = reinterpret_cast< wxWindow * >(argp1);
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 result = ((wxWindow const *)arg1)->GetLayoutDirection();
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
30743 return resultobj;
30744 fail:
30745 return NULL;
30746 }
30747
30748
30749 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30750 PyObject *resultobj = 0;
30751 wxWindow *arg1 = (wxWindow *) 0 ;
30752 wxLayoutDirection arg2 ;
30753 void *argp1 = 0 ;
30754 int res1 = 0 ;
30755 void *argp2 ;
30756 int res2 = 0 ;
30757 PyObject * obj0 = 0 ;
30758 PyObject * obj1 = 0 ;
30759 char * kwnames[] = {
30760 (char *) "self",(char *) "dir", NULL
30761 };
30762
30763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30765 if (!SWIG_IsOK(res1)) {
30766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30767 }
30768 arg1 = reinterpret_cast< wxWindow * >(argp1);
30769 {
30770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxLayoutDirection, 0 | 0);
30771 if (!SWIG_IsOK(res2)) {
30772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30773 }
30774 if (!argp2) {
30775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30776 } else {
30777 wxLayoutDirection * temp = reinterpret_cast< wxLayoutDirection * >(argp2);
30778 arg2 = *temp;
30779 if (SWIG_IsNewObj(res2)) delete temp;
30780 }
30781 }
30782 {
30783 PyThreadState* __tstate = wxPyBeginAllowThreads();
30784 (arg1)->SetLayoutDirection(arg2);
30785 wxPyEndAllowThreads(__tstate);
30786 if (PyErr_Occurred()) SWIG_fail;
30787 }
30788 resultobj = SWIG_Py_Void();
30789 return resultobj;
30790 fail:
30791 return NULL;
30792 }
30793
30794
30795 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30796 PyObject *resultobj = 0;
30797 wxWindow *arg1 = (wxWindow *) 0 ;
30798 int arg2 ;
30799 int arg3 ;
30800 int arg4 ;
30801 int result;
30802 void *argp1 = 0 ;
30803 int res1 = 0 ;
30804 int val2 ;
30805 int ecode2 = 0 ;
30806 int val3 ;
30807 int ecode3 = 0 ;
30808 int val4 ;
30809 int ecode4 = 0 ;
30810 PyObject * obj0 = 0 ;
30811 PyObject * obj1 = 0 ;
30812 PyObject * obj2 = 0 ;
30813 PyObject * obj3 = 0 ;
30814 char * kwnames[] = {
30815 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30816 };
30817
30818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30820 if (!SWIG_IsOK(res1)) {
30821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30822 }
30823 arg1 = reinterpret_cast< wxWindow * >(argp1);
30824 ecode2 = SWIG_AsVal_int(obj1, &val2);
30825 if (!SWIG_IsOK(ecode2)) {
30826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30827 }
30828 arg2 = static_cast< int >(val2);
30829 ecode3 = SWIG_AsVal_int(obj2, &val3);
30830 if (!SWIG_IsOK(ecode3)) {
30831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30832 }
30833 arg3 = static_cast< int >(val3);
30834 ecode4 = SWIG_AsVal_int(obj3, &val4);
30835 if (!SWIG_IsOK(ecode4)) {
30836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30837 }
30838 arg4 = static_cast< int >(val4);
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 resultobj = SWIG_From_int(static_cast< int >(result));
30846 return resultobj;
30847 fail:
30848 return NULL;
30849 }
30850
30851
30852 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30853 PyObject *resultobj = 0;
30854 wxWindow *arg1 = (wxWindow *) 0 ;
30855 wxSize *arg2 = 0 ;
30856 void *argp1 = 0 ;
30857 int res1 = 0 ;
30858 wxSize temp2 ;
30859 PyObject * obj0 = 0 ;
30860 PyObject * obj1 = 0 ;
30861 char * kwnames[] = {
30862 (char *) "self",(char *) "size", NULL
30863 };
30864
30865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30867 if (!SWIG_IsOK(res1)) {
30868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30869 }
30870 arg1 = reinterpret_cast< wxWindow * >(argp1);
30871 {
30872 arg2 = &temp2;
30873 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30874 }
30875 {
30876 PyThreadState* __tstate = wxPyBeginAllowThreads();
30877 (arg1)->SetSize((wxSize const &)*arg2);
30878 wxPyEndAllowThreads(__tstate);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 }
30881 resultobj = SWIG_Py_Void();
30882 return resultobj;
30883 fail:
30884 return NULL;
30885 }
30886
30887
30888 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30889 PyObject *resultobj = 0;
30890 wxWindow *arg1 = (wxWindow *) 0 ;
30891 int arg2 ;
30892 int arg3 ;
30893 int arg4 ;
30894 int arg5 ;
30895 int arg6 = (int) wxSIZE_AUTO ;
30896 void *argp1 = 0 ;
30897 int res1 = 0 ;
30898 int val2 ;
30899 int ecode2 = 0 ;
30900 int val3 ;
30901 int ecode3 = 0 ;
30902 int val4 ;
30903 int ecode4 = 0 ;
30904 int val5 ;
30905 int ecode5 = 0 ;
30906 int val6 ;
30907 int ecode6 = 0 ;
30908 PyObject * obj0 = 0 ;
30909 PyObject * obj1 = 0 ;
30910 PyObject * obj2 = 0 ;
30911 PyObject * obj3 = 0 ;
30912 PyObject * obj4 = 0 ;
30913 PyObject * obj5 = 0 ;
30914 char * kwnames[] = {
30915 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30916 };
30917
30918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30920 if (!SWIG_IsOK(res1)) {
30921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30922 }
30923 arg1 = reinterpret_cast< wxWindow * >(argp1);
30924 ecode2 = SWIG_AsVal_int(obj1, &val2);
30925 if (!SWIG_IsOK(ecode2)) {
30926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30927 }
30928 arg2 = static_cast< int >(val2);
30929 ecode3 = SWIG_AsVal_int(obj2, &val3);
30930 if (!SWIG_IsOK(ecode3)) {
30931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30932 }
30933 arg3 = static_cast< int >(val3);
30934 ecode4 = SWIG_AsVal_int(obj3, &val4);
30935 if (!SWIG_IsOK(ecode4)) {
30936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30937 }
30938 arg4 = static_cast< int >(val4);
30939 ecode5 = SWIG_AsVal_int(obj4, &val5);
30940 if (!SWIG_IsOK(ecode5)) {
30941 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30942 }
30943 arg5 = static_cast< int >(val5);
30944 if (obj5) {
30945 ecode6 = SWIG_AsVal_int(obj5, &val6);
30946 if (!SWIG_IsOK(ecode6)) {
30947 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30948 }
30949 arg6 = static_cast< int >(val6);
30950 }
30951 {
30952 PyThreadState* __tstate = wxPyBeginAllowThreads();
30953 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30954 wxPyEndAllowThreads(__tstate);
30955 if (PyErr_Occurred()) SWIG_fail;
30956 }
30957 resultobj = SWIG_Py_Void();
30958 return resultobj;
30959 fail:
30960 return NULL;
30961 }
30962
30963
30964 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30965 PyObject *resultobj = 0;
30966 wxWindow *arg1 = (wxWindow *) 0 ;
30967 wxRect *arg2 = 0 ;
30968 int arg3 = (int) wxSIZE_AUTO ;
30969 void *argp1 = 0 ;
30970 int res1 = 0 ;
30971 wxRect temp2 ;
30972 int val3 ;
30973 int ecode3 = 0 ;
30974 PyObject * obj0 = 0 ;
30975 PyObject * obj1 = 0 ;
30976 PyObject * obj2 = 0 ;
30977 char * kwnames[] = {
30978 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30979 };
30980
30981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30983 if (!SWIG_IsOK(res1)) {
30984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30985 }
30986 arg1 = reinterpret_cast< wxWindow * >(argp1);
30987 {
30988 arg2 = &temp2;
30989 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30990 }
30991 if (obj2) {
30992 ecode3 = SWIG_AsVal_int(obj2, &val3);
30993 if (!SWIG_IsOK(ecode3)) {
30994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30995 }
30996 arg3 = static_cast< int >(val3);
30997 }
30998 {
30999 PyThreadState* __tstate = wxPyBeginAllowThreads();
31000 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31001 wxPyEndAllowThreads(__tstate);
31002 if (PyErr_Occurred()) SWIG_fail;
31003 }
31004 resultobj = SWIG_Py_Void();
31005 return resultobj;
31006 fail:
31007 return NULL;
31008 }
31009
31010
31011 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31012 PyObject *resultobj = 0;
31013 wxWindow *arg1 = (wxWindow *) 0 ;
31014 int arg2 ;
31015 int arg3 ;
31016 void *argp1 = 0 ;
31017 int res1 = 0 ;
31018 int val2 ;
31019 int ecode2 = 0 ;
31020 int val3 ;
31021 int ecode3 = 0 ;
31022 PyObject * obj0 = 0 ;
31023 PyObject * obj1 = 0 ;
31024 PyObject * obj2 = 0 ;
31025 char * kwnames[] = {
31026 (char *) "self",(char *) "width",(char *) "height", NULL
31027 };
31028
31029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31031 if (!SWIG_IsOK(res1)) {
31032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31033 }
31034 arg1 = reinterpret_cast< wxWindow * >(argp1);
31035 ecode2 = SWIG_AsVal_int(obj1, &val2);
31036 if (!SWIG_IsOK(ecode2)) {
31037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31038 }
31039 arg2 = static_cast< int >(val2);
31040 ecode3 = SWIG_AsVal_int(obj2, &val3);
31041 if (!SWIG_IsOK(ecode3)) {
31042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31043 }
31044 arg3 = static_cast< int >(val3);
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 (arg1)->SetSize(arg2,arg3);
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 resultobj = SWIG_Py_Void();
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31059 PyObject *resultobj = 0;
31060 wxWindow *arg1 = (wxWindow *) 0 ;
31061 wxPoint *arg2 = 0 ;
31062 int arg3 = (int) wxSIZE_USE_EXISTING ;
31063 void *argp1 = 0 ;
31064 int res1 = 0 ;
31065 wxPoint temp2 ;
31066 int val3 ;
31067 int ecode3 = 0 ;
31068 PyObject * obj0 = 0 ;
31069 PyObject * obj1 = 0 ;
31070 PyObject * obj2 = 0 ;
31071 char * kwnames[] = {
31072 (char *) "self",(char *) "pt",(char *) "flags", NULL
31073 };
31074
31075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31077 if (!SWIG_IsOK(res1)) {
31078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31079 }
31080 arg1 = reinterpret_cast< wxWindow * >(argp1);
31081 {
31082 arg2 = &temp2;
31083 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31084 }
31085 if (obj2) {
31086 ecode3 = SWIG_AsVal_int(obj2, &val3);
31087 if (!SWIG_IsOK(ecode3)) {
31088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31089 }
31090 arg3 = static_cast< int >(val3);
31091 }
31092 {
31093 PyThreadState* __tstate = wxPyBeginAllowThreads();
31094 (arg1)->Move((wxPoint const &)*arg2,arg3);
31095 wxPyEndAllowThreads(__tstate);
31096 if (PyErr_Occurred()) SWIG_fail;
31097 }
31098 resultobj = SWIG_Py_Void();
31099 return resultobj;
31100 fail:
31101 return NULL;
31102 }
31103
31104
31105 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31106 PyObject *resultobj = 0;
31107 wxWindow *arg1 = (wxWindow *) 0 ;
31108 int arg2 ;
31109 int arg3 ;
31110 int arg4 = (int) wxSIZE_USE_EXISTING ;
31111 void *argp1 = 0 ;
31112 int res1 = 0 ;
31113 int val2 ;
31114 int ecode2 = 0 ;
31115 int val3 ;
31116 int ecode3 = 0 ;
31117 int val4 ;
31118 int ecode4 = 0 ;
31119 PyObject * obj0 = 0 ;
31120 PyObject * obj1 = 0 ;
31121 PyObject * obj2 = 0 ;
31122 PyObject * obj3 = 0 ;
31123 char * kwnames[] = {
31124 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31125 };
31126
31127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31129 if (!SWIG_IsOK(res1)) {
31130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31131 }
31132 arg1 = reinterpret_cast< wxWindow * >(argp1);
31133 ecode2 = SWIG_AsVal_int(obj1, &val2);
31134 if (!SWIG_IsOK(ecode2)) {
31135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31136 }
31137 arg2 = static_cast< int >(val2);
31138 ecode3 = SWIG_AsVal_int(obj2, &val3);
31139 if (!SWIG_IsOK(ecode3)) {
31140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31141 }
31142 arg3 = static_cast< int >(val3);
31143 if (obj3) {
31144 ecode4 = SWIG_AsVal_int(obj3, &val4);
31145 if (!SWIG_IsOK(ecode4)) {
31146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31147 }
31148 arg4 = static_cast< int >(val4);
31149 }
31150 {
31151 PyThreadState* __tstate = wxPyBeginAllowThreads();
31152 (arg1)->Move(arg2,arg3,arg4);
31153 wxPyEndAllowThreads(__tstate);
31154 if (PyErr_Occurred()) SWIG_fail;
31155 }
31156 resultobj = SWIG_Py_Void();
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31164 PyObject *resultobj = 0;
31165 wxWindow *arg1 = (wxWindow *) 0 ;
31166 wxSize const &arg2_defvalue = wxDefaultSize ;
31167 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31168 void *argp1 = 0 ;
31169 int res1 = 0 ;
31170 wxSize temp2 ;
31171 PyObject * obj0 = 0 ;
31172 PyObject * obj1 = 0 ;
31173 char * kwnames[] = {
31174 (char *) "self",(char *) "size", NULL
31175 };
31176
31177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31179 if (!SWIG_IsOK(res1)) {
31180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31181 }
31182 arg1 = reinterpret_cast< wxWindow * >(argp1);
31183 if (obj1) {
31184 {
31185 arg2 = &temp2;
31186 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31187 }
31188 }
31189 {
31190 PyThreadState* __tstate = wxPyBeginAllowThreads();
31191 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31192 wxPyEndAllowThreads(__tstate);
31193 if (PyErr_Occurred()) SWIG_fail;
31194 }
31195 resultobj = SWIG_Py_Void();
31196 return resultobj;
31197 fail:
31198 return NULL;
31199 }
31200
31201
31202 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31203 PyObject *resultobj = 0;
31204 wxWindow *arg1 = (wxWindow *) 0 ;
31205 void *argp1 = 0 ;
31206 int res1 = 0 ;
31207 PyObject *swig_obj[1] ;
31208
31209 if (!args) SWIG_fail;
31210 swig_obj[0] = args;
31211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31212 if (!SWIG_IsOK(res1)) {
31213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31214 }
31215 arg1 = reinterpret_cast< wxWindow * >(argp1);
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 (arg1)->Raise();
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 resultobj = SWIG_Py_Void();
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31230 PyObject *resultobj = 0;
31231 wxWindow *arg1 = (wxWindow *) 0 ;
31232 void *argp1 = 0 ;
31233 int res1 = 0 ;
31234 PyObject *swig_obj[1] ;
31235
31236 if (!args) SWIG_fail;
31237 swig_obj[0] = args;
31238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31239 if (!SWIG_IsOK(res1)) {
31240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31241 }
31242 arg1 = reinterpret_cast< wxWindow * >(argp1);
31243 {
31244 PyThreadState* __tstate = wxPyBeginAllowThreads();
31245 (arg1)->Lower();
31246 wxPyEndAllowThreads(__tstate);
31247 if (PyErr_Occurred()) SWIG_fail;
31248 }
31249 resultobj = SWIG_Py_Void();
31250 return resultobj;
31251 fail:
31252 return NULL;
31253 }
31254
31255
31256 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31257 PyObject *resultobj = 0;
31258 wxWindow *arg1 = (wxWindow *) 0 ;
31259 wxSize *arg2 = 0 ;
31260 void *argp1 = 0 ;
31261 int res1 = 0 ;
31262 wxSize temp2 ;
31263 PyObject * obj0 = 0 ;
31264 PyObject * obj1 = 0 ;
31265 char * kwnames[] = {
31266 (char *) "self",(char *) "size", NULL
31267 };
31268
31269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31271 if (!SWIG_IsOK(res1)) {
31272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31273 }
31274 arg1 = reinterpret_cast< wxWindow * >(argp1);
31275 {
31276 arg2 = &temp2;
31277 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31278 }
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 (arg1)->SetClientSize((wxSize const &)*arg2);
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_Py_Void();
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31293 PyObject *resultobj = 0;
31294 wxWindow *arg1 = (wxWindow *) 0 ;
31295 int arg2 ;
31296 int arg3 ;
31297 void *argp1 = 0 ;
31298 int res1 = 0 ;
31299 int val2 ;
31300 int ecode2 = 0 ;
31301 int val3 ;
31302 int ecode3 = 0 ;
31303 PyObject * obj0 = 0 ;
31304 PyObject * obj1 = 0 ;
31305 PyObject * obj2 = 0 ;
31306 char * kwnames[] = {
31307 (char *) "self",(char *) "width",(char *) "height", NULL
31308 };
31309
31310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31312 if (!SWIG_IsOK(res1)) {
31313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31314 }
31315 arg1 = reinterpret_cast< wxWindow * >(argp1);
31316 ecode2 = SWIG_AsVal_int(obj1, &val2);
31317 if (!SWIG_IsOK(ecode2)) {
31318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31319 }
31320 arg2 = static_cast< int >(val2);
31321 ecode3 = SWIG_AsVal_int(obj2, &val3);
31322 if (!SWIG_IsOK(ecode3)) {
31323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31324 }
31325 arg3 = static_cast< int >(val3);
31326 {
31327 PyThreadState* __tstate = wxPyBeginAllowThreads();
31328 (arg1)->SetClientSize(arg2,arg3);
31329 wxPyEndAllowThreads(__tstate);
31330 if (PyErr_Occurred()) SWIG_fail;
31331 }
31332 resultobj = SWIG_Py_Void();
31333 return resultobj;
31334 fail:
31335 return NULL;
31336 }
31337
31338
31339 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj = 0;
31341 wxWindow *arg1 = (wxWindow *) 0 ;
31342 wxRect *arg2 = 0 ;
31343 void *argp1 = 0 ;
31344 int res1 = 0 ;
31345 wxRect temp2 ;
31346 PyObject * obj0 = 0 ;
31347 PyObject * obj1 = 0 ;
31348 char * kwnames[] = {
31349 (char *) "self",(char *) "rect", NULL
31350 };
31351
31352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31354 if (!SWIG_IsOK(res1)) {
31355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31356 }
31357 arg1 = reinterpret_cast< wxWindow * >(argp1);
31358 {
31359 arg2 = &temp2;
31360 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31361 }
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 (arg1)->SetClientSize((wxRect const &)*arg2);
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 resultobj = SWIG_Py_Void();
31369 return resultobj;
31370 fail:
31371 return NULL;
31372 }
31373
31374
31375 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31376 PyObject *resultobj = 0;
31377 wxWindow *arg1 = (wxWindow *) 0 ;
31378 wxPoint result;
31379 void *argp1 = 0 ;
31380 int res1 = 0 ;
31381 PyObject *swig_obj[1] ;
31382
31383 if (!args) SWIG_fail;
31384 swig_obj[0] = args;
31385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31386 if (!SWIG_IsOK(res1)) {
31387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31388 }
31389 arg1 = reinterpret_cast< wxWindow * >(argp1);
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 result = ((wxWindow const *)arg1)->GetPosition();
31393 wxPyEndAllowThreads(__tstate);
31394 if (PyErr_Occurred()) SWIG_fail;
31395 }
31396 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31397 return resultobj;
31398 fail:
31399 return NULL;
31400 }
31401
31402
31403 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31404 PyObject *resultobj = 0;
31405 wxWindow *arg1 = (wxWindow *) 0 ;
31406 int *arg2 = (int *) 0 ;
31407 int *arg3 = (int *) 0 ;
31408 void *argp1 = 0 ;
31409 int res1 = 0 ;
31410 int temp2 ;
31411 int res2 = SWIG_TMPOBJ ;
31412 int temp3 ;
31413 int res3 = SWIG_TMPOBJ ;
31414 PyObject *swig_obj[1] ;
31415
31416 arg2 = &temp2;
31417 arg3 = &temp3;
31418 if (!args) SWIG_fail;
31419 swig_obj[0] = args;
31420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31421 if (!SWIG_IsOK(res1)) {
31422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31423 }
31424 arg1 = reinterpret_cast< wxWindow * >(argp1);
31425 {
31426 PyThreadState* __tstate = wxPyBeginAllowThreads();
31427 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31428 wxPyEndAllowThreads(__tstate);
31429 if (PyErr_Occurred()) SWIG_fail;
31430 }
31431 resultobj = SWIG_Py_Void();
31432 if (SWIG_IsTmpObj(res2)) {
31433 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31434 } else {
31435 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31436 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31437 }
31438 if (SWIG_IsTmpObj(res3)) {
31439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31440 } else {
31441 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31443 }
31444 return resultobj;
31445 fail:
31446 return NULL;
31447 }
31448
31449
31450 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31451 PyObject *resultobj = 0;
31452 wxWindow *arg1 = (wxWindow *) 0 ;
31453 wxPoint result;
31454 void *argp1 = 0 ;
31455 int res1 = 0 ;
31456 PyObject *swig_obj[1] ;
31457
31458 if (!args) SWIG_fail;
31459 swig_obj[0] = args;
31460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31461 if (!SWIG_IsOK(res1)) {
31462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31463 }
31464 arg1 = reinterpret_cast< wxWindow * >(argp1);
31465 {
31466 PyThreadState* __tstate = wxPyBeginAllowThreads();
31467 result = ((wxWindow const *)arg1)->GetScreenPosition();
31468 wxPyEndAllowThreads(__tstate);
31469 if (PyErr_Occurred()) SWIG_fail;
31470 }
31471 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31472 return resultobj;
31473 fail:
31474 return NULL;
31475 }
31476
31477
31478 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31479 PyObject *resultobj = 0;
31480 wxWindow *arg1 = (wxWindow *) 0 ;
31481 int *arg2 = (int *) 0 ;
31482 int *arg3 = (int *) 0 ;
31483 void *argp1 = 0 ;
31484 int res1 = 0 ;
31485 int temp2 ;
31486 int res2 = SWIG_TMPOBJ ;
31487 int temp3 ;
31488 int res3 = SWIG_TMPOBJ ;
31489 PyObject *swig_obj[1] ;
31490
31491 arg2 = &temp2;
31492 arg3 = &temp3;
31493 if (!args) SWIG_fail;
31494 swig_obj[0] = args;
31495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31496 if (!SWIG_IsOK(res1)) {
31497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31498 }
31499 arg1 = reinterpret_cast< wxWindow * >(argp1);
31500 {
31501 PyThreadState* __tstate = wxPyBeginAllowThreads();
31502 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31503 wxPyEndAllowThreads(__tstate);
31504 if (PyErr_Occurred()) SWIG_fail;
31505 }
31506 resultobj = SWIG_Py_Void();
31507 if (SWIG_IsTmpObj(res2)) {
31508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31509 } else {
31510 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31512 }
31513 if (SWIG_IsTmpObj(res3)) {
31514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31515 } else {
31516 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31518 }
31519 return resultobj;
31520 fail:
31521 return NULL;
31522 }
31523
31524
31525 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31526 PyObject *resultobj = 0;
31527 wxWindow *arg1 = (wxWindow *) 0 ;
31528 wxRect result;
31529 void *argp1 = 0 ;
31530 int res1 = 0 ;
31531 PyObject *swig_obj[1] ;
31532
31533 if (!args) SWIG_fail;
31534 swig_obj[0] = args;
31535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31536 if (!SWIG_IsOK(res1)) {
31537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31538 }
31539 arg1 = reinterpret_cast< wxWindow * >(argp1);
31540 {
31541 PyThreadState* __tstate = wxPyBeginAllowThreads();
31542 result = ((wxWindow const *)arg1)->GetScreenRect();
31543 wxPyEndAllowThreads(__tstate);
31544 if (PyErr_Occurred()) SWIG_fail;
31545 }
31546 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31547 return resultobj;
31548 fail:
31549 return NULL;
31550 }
31551
31552
31553 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31554 PyObject *resultobj = 0;
31555 wxWindow *arg1 = (wxWindow *) 0 ;
31556 wxSize result;
31557 void *argp1 = 0 ;
31558 int res1 = 0 ;
31559 PyObject *swig_obj[1] ;
31560
31561 if (!args) SWIG_fail;
31562 swig_obj[0] = args;
31563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31564 if (!SWIG_IsOK(res1)) {
31565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31566 }
31567 arg1 = reinterpret_cast< wxWindow * >(argp1);
31568 {
31569 PyThreadState* __tstate = wxPyBeginAllowThreads();
31570 result = ((wxWindow const *)arg1)->GetSize();
31571 wxPyEndAllowThreads(__tstate);
31572 if (PyErr_Occurred()) SWIG_fail;
31573 }
31574 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31575 return resultobj;
31576 fail:
31577 return NULL;
31578 }
31579
31580
31581 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31582 PyObject *resultobj = 0;
31583 wxWindow *arg1 = (wxWindow *) 0 ;
31584 int *arg2 = (int *) 0 ;
31585 int *arg3 = (int *) 0 ;
31586 void *argp1 = 0 ;
31587 int res1 = 0 ;
31588 int temp2 ;
31589 int res2 = SWIG_TMPOBJ ;
31590 int temp3 ;
31591 int res3 = SWIG_TMPOBJ ;
31592 PyObject *swig_obj[1] ;
31593
31594 arg2 = &temp2;
31595 arg3 = &temp3;
31596 if (!args) SWIG_fail;
31597 swig_obj[0] = args;
31598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31599 if (!SWIG_IsOK(res1)) {
31600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31601 }
31602 arg1 = reinterpret_cast< wxWindow * >(argp1);
31603 {
31604 PyThreadState* __tstate = wxPyBeginAllowThreads();
31605 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31606 wxPyEndAllowThreads(__tstate);
31607 if (PyErr_Occurred()) SWIG_fail;
31608 }
31609 resultobj = SWIG_Py_Void();
31610 if (SWIG_IsTmpObj(res2)) {
31611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31612 } else {
31613 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31615 }
31616 if (SWIG_IsTmpObj(res3)) {
31617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31618 } else {
31619 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31621 }
31622 return resultobj;
31623 fail:
31624 return NULL;
31625 }
31626
31627
31628 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31629 PyObject *resultobj = 0;
31630 wxWindow *arg1 = (wxWindow *) 0 ;
31631 wxRect result;
31632 void *argp1 = 0 ;
31633 int res1 = 0 ;
31634 PyObject *swig_obj[1] ;
31635
31636 if (!args) SWIG_fail;
31637 swig_obj[0] = args;
31638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31639 if (!SWIG_IsOK(res1)) {
31640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31641 }
31642 arg1 = reinterpret_cast< wxWindow * >(argp1);
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 result = ((wxWindow const *)arg1)->GetRect();
31646 wxPyEndAllowThreads(__tstate);
31647 if (PyErr_Occurred()) SWIG_fail;
31648 }
31649 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31650 return resultobj;
31651 fail:
31652 return NULL;
31653 }
31654
31655
31656 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31657 PyObject *resultobj = 0;
31658 wxWindow *arg1 = (wxWindow *) 0 ;
31659 wxSize result;
31660 void *argp1 = 0 ;
31661 int res1 = 0 ;
31662 PyObject *swig_obj[1] ;
31663
31664 if (!args) SWIG_fail;
31665 swig_obj[0] = args;
31666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31667 if (!SWIG_IsOK(res1)) {
31668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31669 }
31670 arg1 = reinterpret_cast< wxWindow * >(argp1);
31671 {
31672 PyThreadState* __tstate = wxPyBeginAllowThreads();
31673 result = ((wxWindow const *)arg1)->GetClientSize();
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31685 PyObject *resultobj = 0;
31686 wxWindow *arg1 = (wxWindow *) 0 ;
31687 int *arg2 = (int *) 0 ;
31688 int *arg3 = (int *) 0 ;
31689 void *argp1 = 0 ;
31690 int res1 = 0 ;
31691 int temp2 ;
31692 int res2 = SWIG_TMPOBJ ;
31693 int temp3 ;
31694 int res3 = SWIG_TMPOBJ ;
31695 PyObject *swig_obj[1] ;
31696
31697 arg2 = &temp2;
31698 arg3 = &temp3;
31699 if (!args) SWIG_fail;
31700 swig_obj[0] = args;
31701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31702 if (!SWIG_IsOK(res1)) {
31703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31704 }
31705 arg1 = reinterpret_cast< wxWindow * >(argp1);
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 resultobj = SWIG_Py_Void();
31713 if (SWIG_IsTmpObj(res2)) {
31714 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31715 } else {
31716 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31718 }
31719 if (SWIG_IsTmpObj(res3)) {
31720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31721 } else {
31722 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31724 }
31725 return resultobj;
31726 fail:
31727 return NULL;
31728 }
31729
31730
31731 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31732 PyObject *resultobj = 0;
31733 wxWindow *arg1 = (wxWindow *) 0 ;
31734 wxPoint result;
31735 void *argp1 = 0 ;
31736 int res1 = 0 ;
31737 PyObject *swig_obj[1] ;
31738
31739 if (!args) SWIG_fail;
31740 swig_obj[0] = args;
31741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31742 if (!SWIG_IsOK(res1)) {
31743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31744 }
31745 arg1 = reinterpret_cast< wxWindow * >(argp1);
31746 {
31747 PyThreadState* __tstate = wxPyBeginAllowThreads();
31748 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31749 wxPyEndAllowThreads(__tstate);
31750 if (PyErr_Occurred()) SWIG_fail;
31751 }
31752 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31753 return resultobj;
31754 fail:
31755 return NULL;
31756 }
31757
31758
31759 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31760 PyObject *resultobj = 0;
31761 wxWindow *arg1 = (wxWindow *) 0 ;
31762 wxRect result;
31763 void *argp1 = 0 ;
31764 int res1 = 0 ;
31765 PyObject *swig_obj[1] ;
31766
31767 if (!args) SWIG_fail;
31768 swig_obj[0] = args;
31769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31770 if (!SWIG_IsOK(res1)) {
31771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31772 }
31773 arg1 = reinterpret_cast< wxWindow * >(argp1);
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 result = ((wxWindow const *)arg1)->GetClientRect();
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31788 PyObject *resultobj = 0;
31789 wxWindow *arg1 = (wxWindow *) 0 ;
31790 wxSize result;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 PyObject *swig_obj[1] ;
31794
31795 if (!args) SWIG_fail;
31796 swig_obj[0] = args;
31797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31798 if (!SWIG_IsOK(res1)) {
31799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31800 }
31801 arg1 = reinterpret_cast< wxWindow * >(argp1);
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 result = ((wxWindow const *)arg1)->GetBestSize();
31805 wxPyEndAllowThreads(__tstate);
31806 if (PyErr_Occurred()) SWIG_fail;
31807 }
31808 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31809 return resultobj;
31810 fail:
31811 return NULL;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31816 PyObject *resultobj = 0;
31817 wxWindow *arg1 = (wxWindow *) 0 ;
31818 int *arg2 = (int *) 0 ;
31819 int *arg3 = (int *) 0 ;
31820 void *argp1 = 0 ;
31821 int res1 = 0 ;
31822 int temp2 ;
31823 int res2 = SWIG_TMPOBJ ;
31824 int temp3 ;
31825 int res3 = SWIG_TMPOBJ ;
31826 PyObject *swig_obj[1] ;
31827
31828 arg2 = &temp2;
31829 arg3 = &temp3;
31830 if (!args) SWIG_fail;
31831 swig_obj[0] = args;
31832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31833 if (!SWIG_IsOK(res1)) {
31834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31835 }
31836 arg1 = reinterpret_cast< wxWindow * >(argp1);
31837 {
31838 PyThreadState* __tstate = wxPyBeginAllowThreads();
31839 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31840 wxPyEndAllowThreads(__tstate);
31841 if (PyErr_Occurred()) SWIG_fail;
31842 }
31843 resultobj = SWIG_Py_Void();
31844 if (SWIG_IsTmpObj(res2)) {
31845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31846 } else {
31847 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31849 }
31850 if (SWIG_IsTmpObj(res3)) {
31851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31852 } else {
31853 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31855 }
31856 return resultobj;
31857 fail:
31858 return NULL;
31859 }
31860
31861
31862 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31863 PyObject *resultobj = 0;
31864 wxWindow *arg1 = (wxWindow *) 0 ;
31865 void *argp1 = 0 ;
31866 int res1 = 0 ;
31867 PyObject *swig_obj[1] ;
31868
31869 if (!args) SWIG_fail;
31870 swig_obj[0] = args;
31871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31872 if (!SWIG_IsOK(res1)) {
31873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31874 }
31875 arg1 = reinterpret_cast< wxWindow * >(argp1);
31876 {
31877 PyThreadState* __tstate = wxPyBeginAllowThreads();
31878 (arg1)->InvalidateBestSize();
31879 wxPyEndAllowThreads(__tstate);
31880 if (PyErr_Occurred()) SWIG_fail;
31881 }
31882 resultobj = SWIG_Py_Void();
31883 return resultobj;
31884 fail:
31885 return NULL;
31886 }
31887
31888
31889 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31890 PyObject *resultobj = 0;
31891 wxWindow *arg1 = (wxWindow *) 0 ;
31892 wxSize *arg2 = 0 ;
31893 void *argp1 = 0 ;
31894 int res1 = 0 ;
31895 wxSize temp2 ;
31896 PyObject * obj0 = 0 ;
31897 PyObject * obj1 = 0 ;
31898 char * kwnames[] = {
31899 (char *) "self",(char *) "size", NULL
31900 };
31901
31902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31904 if (!SWIG_IsOK(res1)) {
31905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31906 }
31907 arg1 = reinterpret_cast< wxWindow * >(argp1);
31908 {
31909 arg2 = &temp2;
31910 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31911 }
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31915 wxPyEndAllowThreads(__tstate);
31916 if (PyErr_Occurred()) SWIG_fail;
31917 }
31918 resultobj = SWIG_Py_Void();
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31926 PyObject *resultobj = 0;
31927 wxWindow *arg1 = (wxWindow *) 0 ;
31928 wxSize result;
31929 void *argp1 = 0 ;
31930 int res1 = 0 ;
31931 PyObject *swig_obj[1] ;
31932
31933 if (!args) SWIG_fail;
31934 swig_obj[0] = args;
31935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31936 if (!SWIG_IsOK(res1)) {
31937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31938 }
31939 arg1 = reinterpret_cast< wxWindow * >(argp1);
31940 {
31941 PyThreadState* __tstate = wxPyBeginAllowThreads();
31942 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31943 wxPyEndAllowThreads(__tstate);
31944 if (PyErr_Occurred()) SWIG_fail;
31945 }
31946 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31954 PyObject *resultobj = 0;
31955 wxWindow *arg1 = (wxWindow *) 0 ;
31956 wxSize result;
31957 void *argp1 = 0 ;
31958 int res1 = 0 ;
31959 PyObject *swig_obj[1] ;
31960
31961 if (!args) SWIG_fail;
31962 swig_obj[0] = args;
31963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31964 if (!SWIG_IsOK(res1)) {
31965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31966 }
31967 arg1 = reinterpret_cast< wxWindow * >(argp1);
31968 {
31969 PyThreadState* __tstate = wxPyBeginAllowThreads();
31970 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31971 wxPyEndAllowThreads(__tstate);
31972 if (PyErr_Occurred()) SWIG_fail;
31973 }
31974 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31982 PyObject *resultobj = 0;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 int arg2 = (int) wxBOTH ;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 int val2 ;
31988 int ecode2 = 0 ;
31989 PyObject * obj0 = 0 ;
31990 PyObject * obj1 = 0 ;
31991 char * kwnames[] = {
31992 (char *) "self",(char *) "direction", NULL
31993 };
31994
31995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31997 if (!SWIG_IsOK(res1)) {
31998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31999 }
32000 arg1 = reinterpret_cast< wxWindow * >(argp1);
32001 if (obj1) {
32002 ecode2 = SWIG_AsVal_int(obj1, &val2);
32003 if (!SWIG_IsOK(ecode2)) {
32004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32005 }
32006 arg2 = static_cast< int >(val2);
32007 }
32008 {
32009 PyThreadState* __tstate = wxPyBeginAllowThreads();
32010 (arg1)->Center(arg2);
32011 wxPyEndAllowThreads(__tstate);
32012 if (PyErr_Occurred()) SWIG_fail;
32013 }
32014 resultobj = SWIG_Py_Void();
32015 return resultobj;
32016 fail:
32017 return NULL;
32018 }
32019
32020
32021 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32022 PyObject *resultobj = 0;
32023 wxWindow *arg1 = (wxWindow *) 0 ;
32024 int arg2 = (int) wxBOTH ;
32025 void *argp1 = 0 ;
32026 int res1 = 0 ;
32027 int val2 ;
32028 int ecode2 = 0 ;
32029 PyObject * obj0 = 0 ;
32030 PyObject * obj1 = 0 ;
32031 char * kwnames[] = {
32032 (char *) "self",(char *) "dir", NULL
32033 };
32034
32035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32037 if (!SWIG_IsOK(res1)) {
32038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32039 }
32040 arg1 = reinterpret_cast< wxWindow * >(argp1);
32041 if (obj1) {
32042 ecode2 = SWIG_AsVal_int(obj1, &val2);
32043 if (!SWIG_IsOK(ecode2)) {
32044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32045 }
32046 arg2 = static_cast< int >(val2);
32047 }
32048 {
32049 PyThreadState* __tstate = wxPyBeginAllowThreads();
32050 (arg1)->CenterOnParent(arg2);
32051 wxPyEndAllowThreads(__tstate);
32052 if (PyErr_Occurred()) SWIG_fail;
32053 }
32054 resultobj = SWIG_Py_Void();
32055 return resultobj;
32056 fail:
32057 return NULL;
32058 }
32059
32060
32061 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32062 PyObject *resultobj = 0;
32063 wxWindow *arg1 = (wxWindow *) 0 ;
32064 void *argp1 = 0 ;
32065 int res1 = 0 ;
32066 PyObject *swig_obj[1] ;
32067
32068 if (!args) SWIG_fail;
32069 swig_obj[0] = args;
32070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32071 if (!SWIG_IsOK(res1)) {
32072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32073 }
32074 arg1 = reinterpret_cast< wxWindow * >(argp1);
32075 {
32076 PyThreadState* __tstate = wxPyBeginAllowThreads();
32077 (arg1)->Fit();
32078 wxPyEndAllowThreads(__tstate);
32079 if (PyErr_Occurred()) SWIG_fail;
32080 }
32081 resultobj = SWIG_Py_Void();
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32089 PyObject *resultobj = 0;
32090 wxWindow *arg1 = (wxWindow *) 0 ;
32091 void *argp1 = 0 ;
32092 int res1 = 0 ;
32093 PyObject *swig_obj[1] ;
32094
32095 if (!args) SWIG_fail;
32096 swig_obj[0] = args;
32097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32098 if (!SWIG_IsOK(res1)) {
32099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32100 }
32101 arg1 = reinterpret_cast< wxWindow * >(argp1);
32102 {
32103 PyThreadState* __tstate = wxPyBeginAllowThreads();
32104 (arg1)->FitInside();
32105 wxPyEndAllowThreads(__tstate);
32106 if (PyErr_Occurred()) SWIG_fail;
32107 }
32108 resultobj = SWIG_Py_Void();
32109 return resultobj;
32110 fail:
32111 return NULL;
32112 }
32113
32114
32115 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32116 PyObject *resultobj = 0;
32117 wxWindow *arg1 = (wxWindow *) 0 ;
32118 int arg2 ;
32119 int arg3 ;
32120 int arg4 = (int) -1 ;
32121 int arg5 = (int) -1 ;
32122 int arg6 = (int) -1 ;
32123 int arg7 = (int) -1 ;
32124 void *argp1 = 0 ;
32125 int res1 = 0 ;
32126 int val2 ;
32127 int ecode2 = 0 ;
32128 int val3 ;
32129 int ecode3 = 0 ;
32130 int val4 ;
32131 int ecode4 = 0 ;
32132 int val5 ;
32133 int ecode5 = 0 ;
32134 int val6 ;
32135 int ecode6 = 0 ;
32136 int val7 ;
32137 int ecode7 = 0 ;
32138 PyObject * obj0 = 0 ;
32139 PyObject * obj1 = 0 ;
32140 PyObject * obj2 = 0 ;
32141 PyObject * obj3 = 0 ;
32142 PyObject * obj4 = 0 ;
32143 PyObject * obj5 = 0 ;
32144 PyObject * obj6 = 0 ;
32145 char * kwnames[] = {
32146 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32147 };
32148
32149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32151 if (!SWIG_IsOK(res1)) {
32152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32153 }
32154 arg1 = reinterpret_cast< wxWindow * >(argp1);
32155 ecode2 = SWIG_AsVal_int(obj1, &val2);
32156 if (!SWIG_IsOK(ecode2)) {
32157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32158 }
32159 arg2 = static_cast< int >(val2);
32160 ecode3 = SWIG_AsVal_int(obj2, &val3);
32161 if (!SWIG_IsOK(ecode3)) {
32162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32163 }
32164 arg3 = static_cast< int >(val3);
32165 if (obj3) {
32166 ecode4 = SWIG_AsVal_int(obj3, &val4);
32167 if (!SWIG_IsOK(ecode4)) {
32168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32169 }
32170 arg4 = static_cast< int >(val4);
32171 }
32172 if (obj4) {
32173 ecode5 = SWIG_AsVal_int(obj4, &val5);
32174 if (!SWIG_IsOK(ecode5)) {
32175 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32176 }
32177 arg5 = static_cast< int >(val5);
32178 }
32179 if (obj5) {
32180 ecode6 = SWIG_AsVal_int(obj5, &val6);
32181 if (!SWIG_IsOK(ecode6)) {
32182 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32183 }
32184 arg6 = static_cast< int >(val6);
32185 }
32186 if (obj6) {
32187 ecode7 = SWIG_AsVal_int(obj6, &val7);
32188 if (!SWIG_IsOK(ecode7)) {
32189 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32190 }
32191 arg7 = static_cast< int >(val7);
32192 }
32193 {
32194 PyThreadState* __tstate = wxPyBeginAllowThreads();
32195 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 resultobj = SWIG_Py_Void();
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32207 PyObject *resultobj = 0;
32208 wxWindow *arg1 = (wxWindow *) 0 ;
32209 wxSize *arg2 = 0 ;
32210 wxSize const &arg3_defvalue = wxDefaultSize ;
32211 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32212 wxSize const &arg4_defvalue = wxDefaultSize ;
32213 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32214 void *argp1 = 0 ;
32215 int res1 = 0 ;
32216 wxSize temp2 ;
32217 wxSize temp3 ;
32218 wxSize temp4 ;
32219 PyObject * obj0 = 0 ;
32220 PyObject * obj1 = 0 ;
32221 PyObject * obj2 = 0 ;
32222 PyObject * obj3 = 0 ;
32223 char * kwnames[] = {
32224 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32225 };
32226
32227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32229 if (!SWIG_IsOK(res1)) {
32230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32231 }
32232 arg1 = reinterpret_cast< wxWindow * >(argp1);
32233 {
32234 arg2 = &temp2;
32235 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32236 }
32237 if (obj2) {
32238 {
32239 arg3 = &temp3;
32240 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32241 }
32242 }
32243 if (obj3) {
32244 {
32245 arg4 = &temp4;
32246 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32247 }
32248 }
32249 {
32250 PyThreadState* __tstate = wxPyBeginAllowThreads();
32251 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32252 wxPyEndAllowThreads(__tstate);
32253 if (PyErr_Occurred()) SWIG_fail;
32254 }
32255 resultobj = SWIG_Py_Void();
32256 return resultobj;
32257 fail:
32258 return NULL;
32259 }
32260
32261
32262 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32263 PyObject *resultobj = 0;
32264 wxWindow *arg1 = (wxWindow *) 0 ;
32265 int arg2 ;
32266 int arg3 ;
32267 int arg4 = (int) -1 ;
32268 int arg5 = (int) -1 ;
32269 void *argp1 = 0 ;
32270 int res1 = 0 ;
32271 int val2 ;
32272 int ecode2 = 0 ;
32273 int val3 ;
32274 int ecode3 = 0 ;
32275 int val4 ;
32276 int ecode4 = 0 ;
32277 int val5 ;
32278 int ecode5 = 0 ;
32279 PyObject * obj0 = 0 ;
32280 PyObject * obj1 = 0 ;
32281 PyObject * obj2 = 0 ;
32282 PyObject * obj3 = 0 ;
32283 PyObject * obj4 = 0 ;
32284 char * kwnames[] = {
32285 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32286 };
32287
32288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32290 if (!SWIG_IsOK(res1)) {
32291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32292 }
32293 arg1 = reinterpret_cast< wxWindow * >(argp1);
32294 ecode2 = SWIG_AsVal_int(obj1, &val2);
32295 if (!SWIG_IsOK(ecode2)) {
32296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32297 }
32298 arg2 = static_cast< int >(val2);
32299 ecode3 = SWIG_AsVal_int(obj2, &val3);
32300 if (!SWIG_IsOK(ecode3)) {
32301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32302 }
32303 arg3 = static_cast< int >(val3);
32304 if (obj3) {
32305 ecode4 = SWIG_AsVal_int(obj3, &val4);
32306 if (!SWIG_IsOK(ecode4)) {
32307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32308 }
32309 arg4 = static_cast< int >(val4);
32310 }
32311 if (obj4) {
32312 ecode5 = SWIG_AsVal_int(obj4, &val5);
32313 if (!SWIG_IsOK(ecode5)) {
32314 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32315 }
32316 arg5 = static_cast< int >(val5);
32317 }
32318 {
32319 PyThreadState* __tstate = wxPyBeginAllowThreads();
32320 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32321 wxPyEndAllowThreads(__tstate);
32322 if (PyErr_Occurred()) SWIG_fail;
32323 }
32324 resultobj = SWIG_Py_Void();
32325 return resultobj;
32326 fail:
32327 return NULL;
32328 }
32329
32330
32331 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32332 PyObject *resultobj = 0;
32333 wxWindow *arg1 = (wxWindow *) 0 ;
32334 wxSize *arg2 = 0 ;
32335 wxSize const &arg3_defvalue = wxDefaultSize ;
32336 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32337 void *argp1 = 0 ;
32338 int res1 = 0 ;
32339 wxSize temp2 ;
32340 wxSize temp3 ;
32341 PyObject * obj0 = 0 ;
32342 PyObject * obj1 = 0 ;
32343 PyObject * obj2 = 0 ;
32344 char * kwnames[] = {
32345 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32346 };
32347
32348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32350 if (!SWIG_IsOK(res1)) {
32351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32352 }
32353 arg1 = reinterpret_cast< wxWindow * >(argp1);
32354 {
32355 arg2 = &temp2;
32356 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32357 }
32358 if (obj2) {
32359 {
32360 arg3 = &temp3;
32361 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32362 }
32363 }
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 resultobj = SWIG_Py_Void();
32371 return resultobj;
32372 fail:
32373 return NULL;
32374 }
32375
32376
32377 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32378 PyObject *resultobj = 0;
32379 wxWindow *arg1 = (wxWindow *) 0 ;
32380 wxSize result;
32381 void *argp1 = 0 ;
32382 int res1 = 0 ;
32383 PyObject *swig_obj[1] ;
32384
32385 if (!args) SWIG_fail;
32386 swig_obj[0] = args;
32387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32388 if (!SWIG_IsOK(res1)) {
32389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32390 }
32391 arg1 = reinterpret_cast< wxWindow * >(argp1);
32392 {
32393 PyThreadState* __tstate = wxPyBeginAllowThreads();
32394 result = ((wxWindow const *)arg1)->GetMaxSize();
32395 wxPyEndAllowThreads(__tstate);
32396 if (PyErr_Occurred()) SWIG_fail;
32397 }
32398 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32399 return resultobj;
32400 fail:
32401 return NULL;
32402 }
32403
32404
32405 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32406 PyObject *resultobj = 0;
32407 wxWindow *arg1 = (wxWindow *) 0 ;
32408 wxSize result;
32409 void *argp1 = 0 ;
32410 int res1 = 0 ;
32411 PyObject *swig_obj[1] ;
32412
32413 if (!args) SWIG_fail;
32414 swig_obj[0] = args;
32415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32416 if (!SWIG_IsOK(res1)) {
32417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32418 }
32419 arg1 = reinterpret_cast< wxWindow * >(argp1);
32420 {
32421 PyThreadState* __tstate = wxPyBeginAllowThreads();
32422 result = ((wxWindow const *)arg1)->GetMinSize();
32423 wxPyEndAllowThreads(__tstate);
32424 if (PyErr_Occurred()) SWIG_fail;
32425 }
32426 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32427 return resultobj;
32428 fail:
32429 return NULL;
32430 }
32431
32432
32433 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32434 PyObject *resultobj = 0;
32435 wxWindow *arg1 = (wxWindow *) 0 ;
32436 wxSize *arg2 = 0 ;
32437 void *argp1 = 0 ;
32438 int res1 = 0 ;
32439 wxSize temp2 ;
32440 PyObject * obj0 = 0 ;
32441 PyObject * obj1 = 0 ;
32442 char * kwnames[] = {
32443 (char *) "self",(char *) "minSize", NULL
32444 };
32445
32446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32448 if (!SWIG_IsOK(res1)) {
32449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32450 }
32451 arg1 = reinterpret_cast< wxWindow * >(argp1);
32452 {
32453 arg2 = &temp2;
32454 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32455 }
32456 {
32457 PyThreadState* __tstate = wxPyBeginAllowThreads();
32458 (arg1)->SetMinSize((wxSize const &)*arg2);
32459 wxPyEndAllowThreads(__tstate);
32460 if (PyErr_Occurred()) SWIG_fail;
32461 }
32462 resultobj = SWIG_Py_Void();
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = 0;
32471 wxWindow *arg1 = (wxWindow *) 0 ;
32472 wxSize *arg2 = 0 ;
32473 void *argp1 = 0 ;
32474 int res1 = 0 ;
32475 wxSize temp2 ;
32476 PyObject * obj0 = 0 ;
32477 PyObject * obj1 = 0 ;
32478 char * kwnames[] = {
32479 (char *) "self",(char *) "maxSize", NULL
32480 };
32481
32482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32484 if (!SWIG_IsOK(res1)) {
32485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32486 }
32487 arg1 = reinterpret_cast< wxWindow * >(argp1);
32488 {
32489 arg2 = &temp2;
32490 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32491 }
32492 {
32493 PyThreadState* __tstate = wxPyBeginAllowThreads();
32494 (arg1)->SetMaxSize((wxSize const &)*arg2);
32495 wxPyEndAllowThreads(__tstate);
32496 if (PyErr_Occurred()) SWIG_fail;
32497 }
32498 resultobj = SWIG_Py_Void();
32499 return resultobj;
32500 fail:
32501 return NULL;
32502 }
32503
32504
32505 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32506 PyObject *resultobj = 0;
32507 wxWindow *arg1 = (wxWindow *) 0 ;
32508 int result;
32509 void *argp1 = 0 ;
32510 int res1 = 0 ;
32511 PyObject *swig_obj[1] ;
32512
32513 if (!args) SWIG_fail;
32514 swig_obj[0] = args;
32515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32516 if (!SWIG_IsOK(res1)) {
32517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32518 }
32519 arg1 = reinterpret_cast< wxWindow * >(argp1);
32520 {
32521 PyThreadState* __tstate = wxPyBeginAllowThreads();
32522 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32523 wxPyEndAllowThreads(__tstate);
32524 if (PyErr_Occurred()) SWIG_fail;
32525 }
32526 resultobj = SWIG_From_int(static_cast< int >(result));
32527 return resultobj;
32528 fail:
32529 return NULL;
32530 }
32531
32532
32533 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32534 PyObject *resultobj = 0;
32535 wxWindow *arg1 = (wxWindow *) 0 ;
32536 int result;
32537 void *argp1 = 0 ;
32538 int res1 = 0 ;
32539 PyObject *swig_obj[1] ;
32540
32541 if (!args) SWIG_fail;
32542 swig_obj[0] = args;
32543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32544 if (!SWIG_IsOK(res1)) {
32545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32546 }
32547 arg1 = reinterpret_cast< wxWindow * >(argp1);
32548 {
32549 PyThreadState* __tstate = wxPyBeginAllowThreads();
32550 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32551 wxPyEndAllowThreads(__tstate);
32552 if (PyErr_Occurred()) SWIG_fail;
32553 }
32554 resultobj = SWIG_From_int(static_cast< int >(result));
32555 return resultobj;
32556 fail:
32557 return NULL;
32558 }
32559
32560
32561 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32562 PyObject *resultobj = 0;
32563 wxWindow *arg1 = (wxWindow *) 0 ;
32564 int result;
32565 void *argp1 = 0 ;
32566 int res1 = 0 ;
32567 PyObject *swig_obj[1] ;
32568
32569 if (!args) SWIG_fail;
32570 swig_obj[0] = args;
32571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32572 if (!SWIG_IsOK(res1)) {
32573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32574 }
32575 arg1 = reinterpret_cast< wxWindow * >(argp1);
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32579 wxPyEndAllowThreads(__tstate);
32580 if (PyErr_Occurred()) SWIG_fail;
32581 }
32582 resultobj = SWIG_From_int(static_cast< int >(result));
32583 return resultobj;
32584 fail:
32585 return NULL;
32586 }
32587
32588
32589 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32590 PyObject *resultobj = 0;
32591 wxWindow *arg1 = (wxWindow *) 0 ;
32592 int result;
32593 void *argp1 = 0 ;
32594 int res1 = 0 ;
32595 PyObject *swig_obj[1] ;
32596
32597 if (!args) SWIG_fail;
32598 swig_obj[0] = args;
32599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32600 if (!SWIG_IsOK(res1)) {
32601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32602 }
32603 arg1 = reinterpret_cast< wxWindow * >(argp1);
32604 {
32605 PyThreadState* __tstate = wxPyBeginAllowThreads();
32606 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32607 wxPyEndAllowThreads(__tstate);
32608 if (PyErr_Occurred()) SWIG_fail;
32609 }
32610 resultobj = SWIG_From_int(static_cast< int >(result));
32611 return resultobj;
32612 fail:
32613 return NULL;
32614 }
32615
32616
32617 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32618 PyObject *resultobj = 0;
32619 wxWindow *arg1 = (wxWindow *) 0 ;
32620 wxSize *arg2 = 0 ;
32621 void *argp1 = 0 ;
32622 int res1 = 0 ;
32623 wxSize temp2 ;
32624 PyObject * obj0 = 0 ;
32625 PyObject * obj1 = 0 ;
32626 char * kwnames[] = {
32627 (char *) "self",(char *) "size", NULL
32628 };
32629
32630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32632 if (!SWIG_IsOK(res1)) {
32633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32634 }
32635 arg1 = reinterpret_cast< wxWindow * >(argp1);
32636 {
32637 arg2 = &temp2;
32638 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32639 }
32640 {
32641 PyThreadState* __tstate = wxPyBeginAllowThreads();
32642 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32643 wxPyEndAllowThreads(__tstate);
32644 if (PyErr_Occurred()) SWIG_fail;
32645 }
32646 resultobj = SWIG_Py_Void();
32647 return resultobj;
32648 fail:
32649 return NULL;
32650 }
32651
32652
32653 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32654 PyObject *resultobj = 0;
32655 wxWindow *arg1 = (wxWindow *) 0 ;
32656 int arg2 ;
32657 int arg3 ;
32658 void *argp1 = 0 ;
32659 int res1 = 0 ;
32660 int val2 ;
32661 int ecode2 = 0 ;
32662 int val3 ;
32663 int ecode3 = 0 ;
32664 PyObject * obj0 = 0 ;
32665 PyObject * obj1 = 0 ;
32666 PyObject * obj2 = 0 ;
32667 char * kwnames[] = {
32668 (char *) "self",(char *) "w",(char *) "h", NULL
32669 };
32670
32671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32673 if (!SWIG_IsOK(res1)) {
32674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32675 }
32676 arg1 = reinterpret_cast< wxWindow * >(argp1);
32677 ecode2 = SWIG_AsVal_int(obj1, &val2);
32678 if (!SWIG_IsOK(ecode2)) {
32679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32680 }
32681 arg2 = static_cast< int >(val2);
32682 ecode3 = SWIG_AsVal_int(obj2, &val3);
32683 if (!SWIG_IsOK(ecode3)) {
32684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32685 }
32686 arg3 = static_cast< int >(val3);
32687 {
32688 PyThreadState* __tstate = wxPyBeginAllowThreads();
32689 (arg1)->SetVirtualSize(arg2,arg3);
32690 wxPyEndAllowThreads(__tstate);
32691 if (PyErr_Occurred()) SWIG_fail;
32692 }
32693 resultobj = SWIG_Py_Void();
32694 return resultobj;
32695 fail:
32696 return NULL;
32697 }
32698
32699
32700 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32701 PyObject *resultobj = 0;
32702 wxWindow *arg1 = (wxWindow *) 0 ;
32703 wxSize result;
32704 void *argp1 = 0 ;
32705 int res1 = 0 ;
32706 PyObject *swig_obj[1] ;
32707
32708 if (!args) SWIG_fail;
32709 swig_obj[0] = args;
32710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32711 if (!SWIG_IsOK(res1)) {
32712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32713 }
32714 arg1 = reinterpret_cast< wxWindow * >(argp1);
32715 {
32716 PyThreadState* __tstate = wxPyBeginAllowThreads();
32717 result = ((wxWindow const *)arg1)->GetVirtualSize();
32718 wxPyEndAllowThreads(__tstate);
32719 if (PyErr_Occurred()) SWIG_fail;
32720 }
32721 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32722 return resultobj;
32723 fail:
32724 return NULL;
32725 }
32726
32727
32728 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32729 PyObject *resultobj = 0;
32730 wxWindow *arg1 = (wxWindow *) 0 ;
32731 int *arg2 = (int *) 0 ;
32732 int *arg3 = (int *) 0 ;
32733 void *argp1 = 0 ;
32734 int res1 = 0 ;
32735 int temp2 ;
32736 int res2 = SWIG_TMPOBJ ;
32737 int temp3 ;
32738 int res3 = SWIG_TMPOBJ ;
32739 PyObject *swig_obj[1] ;
32740
32741 arg2 = &temp2;
32742 arg3 = &temp3;
32743 if (!args) SWIG_fail;
32744 swig_obj[0] = args;
32745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32746 if (!SWIG_IsOK(res1)) {
32747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32748 }
32749 arg1 = reinterpret_cast< wxWindow * >(argp1);
32750 {
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32753 wxPyEndAllowThreads(__tstate);
32754 if (PyErr_Occurred()) SWIG_fail;
32755 }
32756 resultobj = SWIG_Py_Void();
32757 if (SWIG_IsTmpObj(res2)) {
32758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32759 } else {
32760 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32762 }
32763 if (SWIG_IsTmpObj(res3)) {
32764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32765 } else {
32766 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32768 }
32769 return resultobj;
32770 fail:
32771 return NULL;
32772 }
32773
32774
32775 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32776 PyObject *resultobj = 0;
32777 wxWindow *arg1 = (wxWindow *) 0 ;
32778 wxSize result;
32779 void *argp1 = 0 ;
32780 int res1 = 0 ;
32781 PyObject *swig_obj[1] ;
32782
32783 if (!args) SWIG_fail;
32784 swig_obj[0] = args;
32785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32786 if (!SWIG_IsOK(res1)) {
32787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32788 }
32789 arg1 = reinterpret_cast< wxWindow * >(argp1);
32790 {
32791 PyThreadState* __tstate = wxPyBeginAllowThreads();
32792 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32793 wxPyEndAllowThreads(__tstate);
32794 if (PyErr_Occurred()) SWIG_fail;
32795 }
32796 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32797 return resultobj;
32798 fail:
32799 return NULL;
32800 }
32801
32802
32803 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32804 PyObject *resultobj = 0;
32805 wxWindow *arg1 = (wxWindow *) 0 ;
32806 bool arg2 = (bool) true ;
32807 bool result;
32808 void *argp1 = 0 ;
32809 int res1 = 0 ;
32810 bool val2 ;
32811 int ecode2 = 0 ;
32812 PyObject * obj0 = 0 ;
32813 PyObject * obj1 = 0 ;
32814 char * kwnames[] = {
32815 (char *) "self",(char *) "show", NULL
32816 };
32817
32818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32820 if (!SWIG_IsOK(res1)) {
32821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32822 }
32823 arg1 = reinterpret_cast< wxWindow * >(argp1);
32824 if (obj1) {
32825 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32826 if (!SWIG_IsOK(ecode2)) {
32827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32828 }
32829 arg2 = static_cast< bool >(val2);
32830 }
32831 {
32832 PyThreadState* __tstate = wxPyBeginAllowThreads();
32833 result = (bool)(arg1)->Show(arg2);
32834 wxPyEndAllowThreads(__tstate);
32835 if (PyErr_Occurred()) SWIG_fail;
32836 }
32837 {
32838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32839 }
32840 return resultobj;
32841 fail:
32842 return NULL;
32843 }
32844
32845
32846 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32847 PyObject *resultobj = 0;
32848 wxWindow *arg1 = (wxWindow *) 0 ;
32849 bool result;
32850 void *argp1 = 0 ;
32851 int res1 = 0 ;
32852 PyObject *swig_obj[1] ;
32853
32854 if (!args) SWIG_fail;
32855 swig_obj[0] = args;
32856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32857 if (!SWIG_IsOK(res1)) {
32858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32859 }
32860 arg1 = reinterpret_cast< wxWindow * >(argp1);
32861 {
32862 PyThreadState* __tstate = wxPyBeginAllowThreads();
32863 result = (bool)(arg1)->Hide();
32864 wxPyEndAllowThreads(__tstate);
32865 if (PyErr_Occurred()) SWIG_fail;
32866 }
32867 {
32868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32869 }
32870 return resultobj;
32871 fail:
32872 return NULL;
32873 }
32874
32875
32876 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32877 PyObject *resultobj = 0;
32878 wxWindow *arg1 = (wxWindow *) 0 ;
32879 bool arg2 = (bool) true ;
32880 bool result;
32881 void *argp1 = 0 ;
32882 int res1 = 0 ;
32883 bool val2 ;
32884 int ecode2 = 0 ;
32885 PyObject * obj0 = 0 ;
32886 PyObject * obj1 = 0 ;
32887 char * kwnames[] = {
32888 (char *) "self",(char *) "enable", NULL
32889 };
32890
32891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32893 if (!SWIG_IsOK(res1)) {
32894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32895 }
32896 arg1 = reinterpret_cast< wxWindow * >(argp1);
32897 if (obj1) {
32898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32899 if (!SWIG_IsOK(ecode2)) {
32900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32901 }
32902 arg2 = static_cast< bool >(val2);
32903 }
32904 {
32905 PyThreadState* __tstate = wxPyBeginAllowThreads();
32906 result = (bool)(arg1)->Enable(arg2);
32907 wxPyEndAllowThreads(__tstate);
32908 if (PyErr_Occurred()) SWIG_fail;
32909 }
32910 {
32911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32912 }
32913 return resultobj;
32914 fail:
32915 return NULL;
32916 }
32917
32918
32919 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32920 PyObject *resultobj = 0;
32921 wxWindow *arg1 = (wxWindow *) 0 ;
32922 bool result;
32923 void *argp1 = 0 ;
32924 int res1 = 0 ;
32925 PyObject *swig_obj[1] ;
32926
32927 if (!args) SWIG_fail;
32928 swig_obj[0] = args;
32929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32930 if (!SWIG_IsOK(res1)) {
32931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32932 }
32933 arg1 = reinterpret_cast< wxWindow * >(argp1);
32934 {
32935 PyThreadState* __tstate = wxPyBeginAllowThreads();
32936 result = (bool)(arg1)->Disable();
32937 wxPyEndAllowThreads(__tstate);
32938 if (PyErr_Occurred()) SWIG_fail;
32939 }
32940 {
32941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32942 }
32943 return resultobj;
32944 fail:
32945 return NULL;
32946 }
32947
32948
32949 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32950 PyObject *resultobj = 0;
32951 wxWindow *arg1 = (wxWindow *) 0 ;
32952 bool result;
32953 void *argp1 = 0 ;
32954 int res1 = 0 ;
32955 PyObject *swig_obj[1] ;
32956
32957 if (!args) SWIG_fail;
32958 swig_obj[0] = args;
32959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32960 if (!SWIG_IsOK(res1)) {
32961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32962 }
32963 arg1 = reinterpret_cast< wxWindow * >(argp1);
32964 {
32965 PyThreadState* __tstate = wxPyBeginAllowThreads();
32966 result = (bool)((wxWindow const *)arg1)->IsShown();
32967 wxPyEndAllowThreads(__tstate);
32968 if (PyErr_Occurred()) SWIG_fail;
32969 }
32970 {
32971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32972 }
32973 return resultobj;
32974 fail:
32975 return NULL;
32976 }
32977
32978
32979 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32980 PyObject *resultobj = 0;
32981 wxWindow *arg1 = (wxWindow *) 0 ;
32982 bool result;
32983 void *argp1 = 0 ;
32984 int res1 = 0 ;
32985 PyObject *swig_obj[1] ;
32986
32987 if (!args) SWIG_fail;
32988 swig_obj[0] = args;
32989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32990 if (!SWIG_IsOK(res1)) {
32991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32992 }
32993 arg1 = reinterpret_cast< wxWindow * >(argp1);
32994 {
32995 PyThreadState* __tstate = wxPyBeginAllowThreads();
32996 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32997 wxPyEndAllowThreads(__tstate);
32998 if (PyErr_Occurred()) SWIG_fail;
32999 }
33000 {
33001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33002 }
33003 return resultobj;
33004 fail:
33005 return NULL;
33006 }
33007
33008
33009 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33010 PyObject *resultobj = 0;
33011 wxWindow *arg1 = (wxWindow *) 0 ;
33012 bool result;
33013 void *argp1 = 0 ;
33014 int res1 = 0 ;
33015 PyObject *swig_obj[1] ;
33016
33017 if (!args) SWIG_fail;
33018 swig_obj[0] = args;
33019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33020 if (!SWIG_IsOK(res1)) {
33021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33022 }
33023 arg1 = reinterpret_cast< wxWindow * >(argp1);
33024 {
33025 PyThreadState* __tstate = wxPyBeginAllowThreads();
33026 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33027 wxPyEndAllowThreads(__tstate);
33028 if (PyErr_Occurred()) SWIG_fail;
33029 }
33030 {
33031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33032 }
33033 return resultobj;
33034 fail:
33035 return NULL;
33036 }
33037
33038
33039 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33040 PyObject *resultobj = 0;
33041 wxWindow *arg1 = (wxWindow *) 0 ;
33042 long arg2 ;
33043 void *argp1 = 0 ;
33044 int res1 = 0 ;
33045 long val2 ;
33046 int ecode2 = 0 ;
33047 PyObject * obj0 = 0 ;
33048 PyObject * obj1 = 0 ;
33049 char * kwnames[] = {
33050 (char *) "self",(char *) "style", NULL
33051 };
33052
33053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33055 if (!SWIG_IsOK(res1)) {
33056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33057 }
33058 arg1 = reinterpret_cast< wxWindow * >(argp1);
33059 ecode2 = SWIG_AsVal_long(obj1, &val2);
33060 if (!SWIG_IsOK(ecode2)) {
33061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33062 }
33063 arg2 = static_cast< long >(val2);
33064 {
33065 PyThreadState* __tstate = wxPyBeginAllowThreads();
33066 (arg1)->SetWindowStyleFlag(arg2);
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 resultobj = SWIG_Py_Void();
33071 return resultobj;
33072 fail:
33073 return NULL;
33074 }
33075
33076
33077 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33078 PyObject *resultobj = 0;
33079 wxWindow *arg1 = (wxWindow *) 0 ;
33080 long result;
33081 void *argp1 = 0 ;
33082 int res1 = 0 ;
33083 PyObject *swig_obj[1] ;
33084
33085 if (!args) SWIG_fail;
33086 swig_obj[0] = args;
33087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33088 if (!SWIG_IsOK(res1)) {
33089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33090 }
33091 arg1 = reinterpret_cast< wxWindow * >(argp1);
33092 {
33093 PyThreadState* __tstate = wxPyBeginAllowThreads();
33094 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 resultobj = SWIG_From_long(static_cast< long >(result));
33099 return resultobj;
33100 fail:
33101 return NULL;
33102 }
33103
33104
33105 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33106 PyObject *resultobj = 0;
33107 wxWindow *arg1 = (wxWindow *) 0 ;
33108 int arg2 ;
33109 bool result;
33110 void *argp1 = 0 ;
33111 int res1 = 0 ;
33112 int val2 ;
33113 int ecode2 = 0 ;
33114 PyObject * obj0 = 0 ;
33115 PyObject * obj1 = 0 ;
33116 char * kwnames[] = {
33117 (char *) "self",(char *) "flag", NULL
33118 };
33119
33120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33122 if (!SWIG_IsOK(res1)) {
33123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33124 }
33125 arg1 = reinterpret_cast< wxWindow * >(argp1);
33126 ecode2 = SWIG_AsVal_int(obj1, &val2);
33127 if (!SWIG_IsOK(ecode2)) {
33128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33129 }
33130 arg2 = static_cast< int >(val2);
33131 {
33132 PyThreadState* __tstate = wxPyBeginAllowThreads();
33133 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33134 wxPyEndAllowThreads(__tstate);
33135 if (PyErr_Occurred()) SWIG_fail;
33136 }
33137 {
33138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33139 }
33140 return resultobj;
33141 fail:
33142 return NULL;
33143 }
33144
33145
33146 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33147 PyObject *resultobj = 0;
33148 wxWindow *arg1 = (wxWindow *) 0 ;
33149 bool result;
33150 void *argp1 = 0 ;
33151 int res1 = 0 ;
33152 PyObject *swig_obj[1] ;
33153
33154 if (!args) SWIG_fail;
33155 swig_obj[0] = args;
33156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33157 if (!SWIG_IsOK(res1)) {
33158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33159 }
33160 arg1 = reinterpret_cast< wxWindow * >(argp1);
33161 {
33162 PyThreadState* __tstate = wxPyBeginAllowThreads();
33163 result = (bool)((wxWindow const *)arg1)->IsRetained();
33164 wxPyEndAllowThreads(__tstate);
33165 if (PyErr_Occurred()) SWIG_fail;
33166 }
33167 {
33168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33169 }
33170 return resultobj;
33171 fail:
33172 return NULL;
33173 }
33174
33175
33176 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33177 PyObject *resultobj = 0;
33178 wxWindow *arg1 = (wxWindow *) 0 ;
33179 long arg2 ;
33180 void *argp1 = 0 ;
33181 int res1 = 0 ;
33182 long val2 ;
33183 int ecode2 = 0 ;
33184 PyObject * obj0 = 0 ;
33185 PyObject * obj1 = 0 ;
33186 char * kwnames[] = {
33187 (char *) "self",(char *) "exStyle", NULL
33188 };
33189
33190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33192 if (!SWIG_IsOK(res1)) {
33193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33194 }
33195 arg1 = reinterpret_cast< wxWindow * >(argp1);
33196 ecode2 = SWIG_AsVal_long(obj1, &val2);
33197 if (!SWIG_IsOK(ecode2)) {
33198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33199 }
33200 arg2 = static_cast< long >(val2);
33201 {
33202 PyThreadState* __tstate = wxPyBeginAllowThreads();
33203 (arg1)->SetExtraStyle(arg2);
33204 wxPyEndAllowThreads(__tstate);
33205 if (PyErr_Occurred()) SWIG_fail;
33206 }
33207 resultobj = SWIG_Py_Void();
33208 return resultobj;
33209 fail:
33210 return NULL;
33211 }
33212
33213
33214 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33215 PyObject *resultobj = 0;
33216 wxWindow *arg1 = (wxWindow *) 0 ;
33217 long result;
33218 void *argp1 = 0 ;
33219 int res1 = 0 ;
33220 PyObject *swig_obj[1] ;
33221
33222 if (!args) SWIG_fail;
33223 swig_obj[0] = args;
33224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33225 if (!SWIG_IsOK(res1)) {
33226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33227 }
33228 arg1 = reinterpret_cast< wxWindow * >(argp1);
33229 {
33230 PyThreadState* __tstate = wxPyBeginAllowThreads();
33231 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33232 wxPyEndAllowThreads(__tstate);
33233 if (PyErr_Occurred()) SWIG_fail;
33234 }
33235 resultobj = SWIG_From_long(static_cast< long >(result));
33236 return resultobj;
33237 fail:
33238 return NULL;
33239 }
33240
33241
33242 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33243 PyObject *resultobj = 0;
33244 wxWindow *arg1 = (wxWindow *) 0 ;
33245 bool arg2 = (bool) true ;
33246 void *argp1 = 0 ;
33247 int res1 = 0 ;
33248 bool val2 ;
33249 int ecode2 = 0 ;
33250 PyObject * obj0 = 0 ;
33251 PyObject * obj1 = 0 ;
33252 char * kwnames[] = {
33253 (char *) "self",(char *) "modal", NULL
33254 };
33255
33256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33258 if (!SWIG_IsOK(res1)) {
33259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33260 }
33261 arg1 = reinterpret_cast< wxWindow * >(argp1);
33262 if (obj1) {
33263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33264 if (!SWIG_IsOK(ecode2)) {
33265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33266 }
33267 arg2 = static_cast< bool >(val2);
33268 }
33269 {
33270 PyThreadState* __tstate = wxPyBeginAllowThreads();
33271 (arg1)->MakeModal(arg2);
33272 wxPyEndAllowThreads(__tstate);
33273 if (PyErr_Occurred()) SWIG_fail;
33274 }
33275 resultobj = SWIG_Py_Void();
33276 return resultobj;
33277 fail:
33278 return NULL;
33279 }
33280
33281
33282 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33283 PyObject *resultobj = 0;
33284 wxWindow *arg1 = (wxWindow *) 0 ;
33285 bool arg2 ;
33286 void *argp1 = 0 ;
33287 int res1 = 0 ;
33288 bool val2 ;
33289 int ecode2 = 0 ;
33290 PyObject * obj0 = 0 ;
33291 PyObject * obj1 = 0 ;
33292 char * kwnames[] = {
33293 (char *) "self",(char *) "enableTheme", NULL
33294 };
33295
33296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33298 if (!SWIG_IsOK(res1)) {
33299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33300 }
33301 arg1 = reinterpret_cast< wxWindow * >(argp1);
33302 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33303 if (!SWIG_IsOK(ecode2)) {
33304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33305 }
33306 arg2 = static_cast< bool >(val2);
33307 {
33308 PyThreadState* __tstate = wxPyBeginAllowThreads();
33309 (arg1)->SetThemeEnabled(arg2);
33310 wxPyEndAllowThreads(__tstate);
33311 if (PyErr_Occurred()) SWIG_fail;
33312 }
33313 resultobj = SWIG_Py_Void();
33314 return resultobj;
33315 fail:
33316 return NULL;
33317 }
33318
33319
33320 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33321 PyObject *resultobj = 0;
33322 wxWindow *arg1 = (wxWindow *) 0 ;
33323 bool result;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 PyObject *swig_obj[1] ;
33327
33328 if (!args) SWIG_fail;
33329 swig_obj[0] = args;
33330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33331 if (!SWIG_IsOK(res1)) {
33332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33333 }
33334 arg1 = reinterpret_cast< wxWindow * >(argp1);
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 {
33342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33343 }
33344 return resultobj;
33345 fail:
33346 return NULL;
33347 }
33348
33349
33350 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33351 PyObject *resultobj = 0;
33352 wxWindow *arg1 = (wxWindow *) 0 ;
33353 void *argp1 = 0 ;
33354 int res1 = 0 ;
33355 PyObject *swig_obj[1] ;
33356
33357 if (!args) SWIG_fail;
33358 swig_obj[0] = args;
33359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33360 if (!SWIG_IsOK(res1)) {
33361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33362 }
33363 arg1 = reinterpret_cast< wxWindow * >(argp1);
33364 {
33365 PyThreadState* __tstate = wxPyBeginAllowThreads();
33366 (arg1)->SetFocus();
33367 wxPyEndAllowThreads(__tstate);
33368 if (PyErr_Occurred()) SWIG_fail;
33369 }
33370 resultobj = SWIG_Py_Void();
33371 return resultobj;
33372 fail:
33373 return NULL;
33374 }
33375
33376
33377 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33378 PyObject *resultobj = 0;
33379 wxWindow *arg1 = (wxWindow *) 0 ;
33380 void *argp1 = 0 ;
33381 int res1 = 0 ;
33382 PyObject *swig_obj[1] ;
33383
33384 if (!args) SWIG_fail;
33385 swig_obj[0] = args;
33386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33387 if (!SWIG_IsOK(res1)) {
33388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33389 }
33390 arg1 = reinterpret_cast< wxWindow * >(argp1);
33391 {
33392 PyThreadState* __tstate = wxPyBeginAllowThreads();
33393 (arg1)->SetFocusFromKbd();
33394 wxPyEndAllowThreads(__tstate);
33395 if (PyErr_Occurred()) SWIG_fail;
33396 }
33397 resultobj = SWIG_Py_Void();
33398 return resultobj;
33399 fail:
33400 return NULL;
33401 }
33402
33403
33404 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33405 PyObject *resultobj = 0;
33406 wxWindow *result = 0 ;
33407
33408 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33409 {
33410 if (!wxPyCheckForApp()) SWIG_fail;
33411 PyThreadState* __tstate = wxPyBeginAllowThreads();
33412 result = (wxWindow *)wxWindow::FindFocus();
33413 wxPyEndAllowThreads(__tstate);
33414 if (PyErr_Occurred()) SWIG_fail;
33415 }
33416 {
33417 resultobj = wxPyMake_wxObject(result, 0);
33418 }
33419 return resultobj;
33420 fail:
33421 return NULL;
33422 }
33423
33424
33425 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33426 PyObject *resultobj = 0;
33427 wxWindow *arg1 = (wxWindow *) 0 ;
33428 bool result;
33429 void *argp1 = 0 ;
33430 int res1 = 0 ;
33431 PyObject *swig_obj[1] ;
33432
33433 if (!args) SWIG_fail;
33434 swig_obj[0] = args;
33435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33436 if (!SWIG_IsOK(res1)) {
33437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33438 }
33439 arg1 = reinterpret_cast< wxWindow * >(argp1);
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33443 wxPyEndAllowThreads(__tstate);
33444 if (PyErr_Occurred()) SWIG_fail;
33445 }
33446 {
33447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33448 }
33449 return resultobj;
33450 fail:
33451 return NULL;
33452 }
33453
33454
33455 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33456 PyObject *resultobj = 0;
33457 wxWindow *arg1 = (wxWindow *) 0 ;
33458 bool result;
33459 void *argp1 = 0 ;
33460 int res1 = 0 ;
33461 PyObject *swig_obj[1] ;
33462
33463 if (!args) SWIG_fail;
33464 swig_obj[0] = args;
33465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33466 if (!SWIG_IsOK(res1)) {
33467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33468 }
33469 arg1 = reinterpret_cast< wxWindow * >(argp1);
33470 {
33471 PyThreadState* __tstate = wxPyBeginAllowThreads();
33472 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33473 wxPyEndAllowThreads(__tstate);
33474 if (PyErr_Occurred()) SWIG_fail;
33475 }
33476 {
33477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33478 }
33479 return resultobj;
33480 fail:
33481 return NULL;
33482 }
33483
33484
33485 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33486 PyObject *resultobj = 0;
33487 wxWindow *arg1 = (wxWindow *) 0 ;
33488 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33489 bool result;
33490 void *argp1 = 0 ;
33491 int res1 = 0 ;
33492 int val2 ;
33493 int ecode2 = 0 ;
33494 PyObject * obj0 = 0 ;
33495 PyObject * obj1 = 0 ;
33496 char * kwnames[] = {
33497 (char *) "self",(char *) "flags", NULL
33498 };
33499
33500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33502 if (!SWIG_IsOK(res1)) {
33503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33504 }
33505 arg1 = reinterpret_cast< wxWindow * >(argp1);
33506 if (obj1) {
33507 ecode2 = SWIG_AsVal_int(obj1, &val2);
33508 if (!SWIG_IsOK(ecode2)) {
33509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33510 }
33511 arg2 = static_cast< int >(val2);
33512 }
33513 {
33514 PyThreadState* __tstate = wxPyBeginAllowThreads();
33515 result = (bool)(arg1)->Navigate(arg2);
33516 wxPyEndAllowThreads(__tstate);
33517 if (PyErr_Occurred()) SWIG_fail;
33518 }
33519 {
33520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33521 }
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33529 PyObject *resultobj = 0;
33530 wxWindow *arg1 = (wxWindow *) 0 ;
33531 wxWindow *arg2 = (wxWindow *) 0 ;
33532 void *argp1 = 0 ;
33533 int res1 = 0 ;
33534 void *argp2 = 0 ;
33535 int res2 = 0 ;
33536 PyObject * obj0 = 0 ;
33537 PyObject * obj1 = 0 ;
33538 char * kwnames[] = {
33539 (char *) "self",(char *) "win", NULL
33540 };
33541
33542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33544 if (!SWIG_IsOK(res1)) {
33545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33546 }
33547 arg1 = reinterpret_cast< wxWindow * >(argp1);
33548 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33549 if (!SWIG_IsOK(res2)) {
33550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33551 }
33552 arg2 = reinterpret_cast< wxWindow * >(argp2);
33553 {
33554 PyThreadState* __tstate = wxPyBeginAllowThreads();
33555 (arg1)->MoveAfterInTabOrder(arg2);
33556 wxPyEndAllowThreads(__tstate);
33557 if (PyErr_Occurred()) SWIG_fail;
33558 }
33559 resultobj = SWIG_Py_Void();
33560 return resultobj;
33561 fail:
33562 return NULL;
33563 }
33564
33565
33566 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33567 PyObject *resultobj = 0;
33568 wxWindow *arg1 = (wxWindow *) 0 ;
33569 wxWindow *arg2 = (wxWindow *) 0 ;
33570 void *argp1 = 0 ;
33571 int res1 = 0 ;
33572 void *argp2 = 0 ;
33573 int res2 = 0 ;
33574 PyObject * obj0 = 0 ;
33575 PyObject * obj1 = 0 ;
33576 char * kwnames[] = {
33577 (char *) "self",(char *) "win", NULL
33578 };
33579
33580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33582 if (!SWIG_IsOK(res1)) {
33583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33584 }
33585 arg1 = reinterpret_cast< wxWindow * >(argp1);
33586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33587 if (!SWIG_IsOK(res2)) {
33588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33589 }
33590 arg2 = reinterpret_cast< wxWindow * >(argp2);
33591 {
33592 PyThreadState* __tstate = wxPyBeginAllowThreads();
33593 (arg1)->MoveBeforeInTabOrder(arg2);
33594 wxPyEndAllowThreads(__tstate);
33595 if (PyErr_Occurred()) SWIG_fail;
33596 }
33597 resultobj = SWIG_Py_Void();
33598 return resultobj;
33599 fail:
33600 return NULL;
33601 }
33602
33603
33604 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33605 PyObject *resultobj = 0;
33606 wxWindow *arg1 = (wxWindow *) 0 ;
33607 PyObject *result = 0 ;
33608 void *argp1 = 0 ;
33609 int res1 = 0 ;
33610 PyObject *swig_obj[1] ;
33611
33612 if (!args) SWIG_fail;
33613 swig_obj[0] = args;
33614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33615 if (!SWIG_IsOK(res1)) {
33616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33617 }
33618 arg1 = reinterpret_cast< wxWindow * >(argp1);
33619 {
33620 PyThreadState* __tstate = wxPyBeginAllowThreads();
33621 result = (PyObject *)wxWindow_GetChildren(arg1);
33622 wxPyEndAllowThreads(__tstate);
33623 if (PyErr_Occurred()) SWIG_fail;
33624 }
33625 resultobj = result;
33626 return resultobj;
33627 fail:
33628 return NULL;
33629 }
33630
33631
33632 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33633 PyObject *resultobj = 0;
33634 wxWindow *arg1 = (wxWindow *) 0 ;
33635 wxWindow *result = 0 ;
33636 void *argp1 = 0 ;
33637 int res1 = 0 ;
33638 PyObject *swig_obj[1] ;
33639
33640 if (!args) SWIG_fail;
33641 swig_obj[0] = args;
33642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33643 if (!SWIG_IsOK(res1)) {
33644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33645 }
33646 arg1 = reinterpret_cast< wxWindow * >(argp1);
33647 {
33648 PyThreadState* __tstate = wxPyBeginAllowThreads();
33649 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33650 wxPyEndAllowThreads(__tstate);
33651 if (PyErr_Occurred()) SWIG_fail;
33652 }
33653 {
33654 resultobj = wxPyMake_wxObject(result, 0);
33655 }
33656 return resultobj;
33657 fail:
33658 return NULL;
33659 }
33660
33661
33662 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33663 PyObject *resultobj = 0;
33664 wxWindow *arg1 = (wxWindow *) 0 ;
33665 wxWindow *result = 0 ;
33666 void *argp1 = 0 ;
33667 int res1 = 0 ;
33668 PyObject *swig_obj[1] ;
33669
33670 if (!args) SWIG_fail;
33671 swig_obj[0] = args;
33672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33673 if (!SWIG_IsOK(res1)) {
33674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33675 }
33676 arg1 = reinterpret_cast< wxWindow * >(argp1);
33677 {
33678 PyThreadState* __tstate = wxPyBeginAllowThreads();
33679 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33680 wxPyEndAllowThreads(__tstate);
33681 if (PyErr_Occurred()) SWIG_fail;
33682 }
33683 {
33684 resultobj = wxPyMake_wxObject(result, 0);
33685 }
33686 return resultobj;
33687 fail:
33688 return NULL;
33689 }
33690
33691
33692 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33693 PyObject *resultobj = 0;
33694 wxWindow *arg1 = (wxWindow *) 0 ;
33695 bool result;
33696 void *argp1 = 0 ;
33697 int res1 = 0 ;
33698 PyObject *swig_obj[1] ;
33699
33700 if (!args) SWIG_fail;
33701 swig_obj[0] = args;
33702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33703 if (!SWIG_IsOK(res1)) {
33704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33705 }
33706 arg1 = reinterpret_cast< wxWindow * >(argp1);
33707 {
33708 PyThreadState* __tstate = wxPyBeginAllowThreads();
33709 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33710 wxPyEndAllowThreads(__tstate);
33711 if (PyErr_Occurred()) SWIG_fail;
33712 }
33713 {
33714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33715 }
33716 return resultobj;
33717 fail:
33718 return NULL;
33719 }
33720
33721
33722 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33723 PyObject *resultobj = 0;
33724 wxWindow *arg1 = (wxWindow *) 0 ;
33725 wxWindow *arg2 = (wxWindow *) 0 ;
33726 bool result;
33727 void *argp1 = 0 ;
33728 int res1 = 0 ;
33729 void *argp2 = 0 ;
33730 int res2 = 0 ;
33731 PyObject * obj0 = 0 ;
33732 PyObject * obj1 = 0 ;
33733 char * kwnames[] = {
33734 (char *) "self",(char *) "newParent", NULL
33735 };
33736
33737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33739 if (!SWIG_IsOK(res1)) {
33740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33741 }
33742 arg1 = reinterpret_cast< wxWindow * >(argp1);
33743 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33744 if (!SWIG_IsOK(res2)) {
33745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33746 }
33747 arg2 = reinterpret_cast< wxWindow * >(argp2);
33748 {
33749 PyThreadState* __tstate = wxPyBeginAllowThreads();
33750 result = (bool)(arg1)->Reparent(arg2);
33751 wxPyEndAllowThreads(__tstate);
33752 if (PyErr_Occurred()) SWIG_fail;
33753 }
33754 {
33755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33756 }
33757 return resultobj;
33758 fail:
33759 return NULL;
33760 }
33761
33762
33763 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33764 PyObject *resultobj = 0;
33765 wxWindow *arg1 = (wxWindow *) 0 ;
33766 wxWindow *arg2 = (wxWindow *) 0 ;
33767 void *argp1 = 0 ;
33768 int res1 = 0 ;
33769 void *argp2 = 0 ;
33770 int res2 = 0 ;
33771 PyObject * obj0 = 0 ;
33772 PyObject * obj1 = 0 ;
33773 char * kwnames[] = {
33774 (char *) "self",(char *) "child", NULL
33775 };
33776
33777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33779 if (!SWIG_IsOK(res1)) {
33780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33781 }
33782 arg1 = reinterpret_cast< wxWindow * >(argp1);
33783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33784 if (!SWIG_IsOK(res2)) {
33785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33786 }
33787 arg2 = reinterpret_cast< wxWindow * >(argp2);
33788 {
33789 PyThreadState* __tstate = wxPyBeginAllowThreads();
33790 (arg1)->AddChild(arg2);
33791 wxPyEndAllowThreads(__tstate);
33792 if (PyErr_Occurred()) SWIG_fail;
33793 }
33794 resultobj = SWIG_Py_Void();
33795 return resultobj;
33796 fail:
33797 return NULL;
33798 }
33799
33800
33801 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33802 PyObject *resultobj = 0;
33803 wxWindow *arg1 = (wxWindow *) 0 ;
33804 wxWindow *arg2 = (wxWindow *) 0 ;
33805 void *argp1 = 0 ;
33806 int res1 = 0 ;
33807 void *argp2 = 0 ;
33808 int res2 = 0 ;
33809 PyObject * obj0 = 0 ;
33810 PyObject * obj1 = 0 ;
33811 char * kwnames[] = {
33812 (char *) "self",(char *) "child", NULL
33813 };
33814
33815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33817 if (!SWIG_IsOK(res1)) {
33818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33819 }
33820 arg1 = reinterpret_cast< wxWindow * >(argp1);
33821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33822 if (!SWIG_IsOK(res2)) {
33823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33824 }
33825 arg2 = reinterpret_cast< wxWindow * >(argp2);
33826 {
33827 PyThreadState* __tstate = wxPyBeginAllowThreads();
33828 (arg1)->RemoveChild(arg2);
33829 wxPyEndAllowThreads(__tstate);
33830 if (PyErr_Occurred()) SWIG_fail;
33831 }
33832 resultobj = SWIG_Py_Void();
33833 return resultobj;
33834 fail:
33835 return NULL;
33836 }
33837
33838
33839 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33840 PyObject *resultobj = 0;
33841 wxWindow *arg1 = (wxWindow *) 0 ;
33842 bool arg2 ;
33843 void *argp1 = 0 ;
33844 int res1 = 0 ;
33845 bool val2 ;
33846 int ecode2 = 0 ;
33847 PyObject * obj0 = 0 ;
33848 PyObject * obj1 = 0 ;
33849 char * kwnames[] = {
33850 (char *) "self",(char *) "on", NULL
33851 };
33852
33853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33855 if (!SWIG_IsOK(res1)) {
33856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33857 }
33858 arg1 = reinterpret_cast< wxWindow * >(argp1);
33859 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33860 if (!SWIG_IsOK(ecode2)) {
33861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33862 }
33863 arg2 = static_cast< bool >(val2);
33864 {
33865 PyThreadState* __tstate = wxPyBeginAllowThreads();
33866 wxWindow_SetDoubleBuffered(arg1,arg2);
33867 wxPyEndAllowThreads(__tstate);
33868 if (PyErr_Occurred()) SWIG_fail;
33869 }
33870 resultobj = SWIG_Py_Void();
33871 return resultobj;
33872 fail:
33873 return NULL;
33874 }
33875
33876
33877 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33878 PyObject *resultobj = 0;
33879 wxWindow *arg1 = (wxWindow *) 0 ;
33880 long arg2 ;
33881 wxWindow *result = 0 ;
33882 void *argp1 = 0 ;
33883 int res1 = 0 ;
33884 long val2 ;
33885 int ecode2 = 0 ;
33886 PyObject * obj0 = 0 ;
33887 PyObject * obj1 = 0 ;
33888 char * kwnames[] = {
33889 (char *) "self",(char *) "winid", NULL
33890 };
33891
33892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33894 if (!SWIG_IsOK(res1)) {
33895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33896 }
33897 arg1 = reinterpret_cast< wxWindow * >(argp1);
33898 ecode2 = SWIG_AsVal_long(obj1, &val2);
33899 if (!SWIG_IsOK(ecode2)) {
33900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33901 }
33902 arg2 = static_cast< long >(val2);
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 result = (wxWindow *)(arg1)->FindWindow(arg2);
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 {
33910 resultobj = wxPyMake_wxObject(result, 0);
33911 }
33912 return resultobj;
33913 fail:
33914 return NULL;
33915 }
33916
33917
33918 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33919 PyObject *resultobj = 0;
33920 wxWindow *arg1 = (wxWindow *) 0 ;
33921 wxString *arg2 = 0 ;
33922 wxWindow *result = 0 ;
33923 void *argp1 = 0 ;
33924 int res1 = 0 ;
33925 bool temp2 = false ;
33926 PyObject * obj0 = 0 ;
33927 PyObject * obj1 = 0 ;
33928 char * kwnames[] = {
33929 (char *) "self",(char *) "name", NULL
33930 };
33931
33932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33934 if (!SWIG_IsOK(res1)) {
33935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33936 }
33937 arg1 = reinterpret_cast< wxWindow * >(argp1);
33938 {
33939 arg2 = wxString_in_helper(obj1);
33940 if (arg2 == NULL) SWIG_fail;
33941 temp2 = true;
33942 }
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 {
33950 resultobj = wxPyMake_wxObject(result, 0);
33951 }
33952 {
33953 if (temp2)
33954 delete arg2;
33955 }
33956 return resultobj;
33957 fail:
33958 {
33959 if (temp2)
33960 delete arg2;
33961 }
33962 return NULL;
33963 }
33964
33965
33966 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33967 PyObject *resultobj = 0;
33968 wxWindow *arg1 = (wxWindow *) 0 ;
33969 wxEvtHandler *result = 0 ;
33970 void *argp1 = 0 ;
33971 int res1 = 0 ;
33972 PyObject *swig_obj[1] ;
33973
33974 if (!args) SWIG_fail;
33975 swig_obj[0] = args;
33976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33977 if (!SWIG_IsOK(res1)) {
33978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33979 }
33980 arg1 = reinterpret_cast< wxWindow * >(argp1);
33981 {
33982 PyThreadState* __tstate = wxPyBeginAllowThreads();
33983 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33984 wxPyEndAllowThreads(__tstate);
33985 if (PyErr_Occurred()) SWIG_fail;
33986 }
33987 {
33988 resultobj = wxPyMake_wxObject(result, 0);
33989 }
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33997 PyObject *resultobj = 0;
33998 wxWindow *arg1 = (wxWindow *) 0 ;
33999 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34000 void *argp1 = 0 ;
34001 int res1 = 0 ;
34002 void *argp2 = 0 ;
34003 int res2 = 0 ;
34004 PyObject * obj0 = 0 ;
34005 PyObject * obj1 = 0 ;
34006 char * kwnames[] = {
34007 (char *) "self",(char *) "handler", NULL
34008 };
34009
34010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34012 if (!SWIG_IsOK(res1)) {
34013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34014 }
34015 arg1 = reinterpret_cast< wxWindow * >(argp1);
34016 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34017 if (!SWIG_IsOK(res2)) {
34018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34019 }
34020 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34021 {
34022 PyThreadState* __tstate = wxPyBeginAllowThreads();
34023 (arg1)->SetEventHandler(arg2);
34024 wxPyEndAllowThreads(__tstate);
34025 if (PyErr_Occurred()) SWIG_fail;
34026 }
34027 resultobj = SWIG_Py_Void();
34028 return resultobj;
34029 fail:
34030 return NULL;
34031 }
34032
34033
34034 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34035 PyObject *resultobj = 0;
34036 wxWindow *arg1 = (wxWindow *) 0 ;
34037 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34038 void *argp1 = 0 ;
34039 int res1 = 0 ;
34040 void *argp2 = 0 ;
34041 int res2 = 0 ;
34042 PyObject * obj0 = 0 ;
34043 PyObject * obj1 = 0 ;
34044 char * kwnames[] = {
34045 (char *) "self",(char *) "handler", NULL
34046 };
34047
34048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34050 if (!SWIG_IsOK(res1)) {
34051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34052 }
34053 arg1 = reinterpret_cast< wxWindow * >(argp1);
34054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34055 if (!SWIG_IsOK(res2)) {
34056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34057 }
34058 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34059 {
34060 PyThreadState* __tstate = wxPyBeginAllowThreads();
34061 (arg1)->PushEventHandler(arg2);
34062 wxPyEndAllowThreads(__tstate);
34063 if (PyErr_Occurred()) SWIG_fail;
34064 }
34065 resultobj = SWIG_Py_Void();
34066 return resultobj;
34067 fail:
34068 return NULL;
34069 }
34070
34071
34072 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34073 PyObject *resultobj = 0;
34074 wxWindow *arg1 = (wxWindow *) 0 ;
34075 bool arg2 = (bool) false ;
34076 wxEvtHandler *result = 0 ;
34077 void *argp1 = 0 ;
34078 int res1 = 0 ;
34079 bool val2 ;
34080 int ecode2 = 0 ;
34081 PyObject * obj0 = 0 ;
34082 PyObject * obj1 = 0 ;
34083 char * kwnames[] = {
34084 (char *) "self",(char *) "deleteHandler", NULL
34085 };
34086
34087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34089 if (!SWIG_IsOK(res1)) {
34090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34091 }
34092 arg1 = reinterpret_cast< wxWindow * >(argp1);
34093 if (obj1) {
34094 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34095 if (!SWIG_IsOK(ecode2)) {
34096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34097 }
34098 arg2 = static_cast< bool >(val2);
34099 }
34100 {
34101 PyThreadState* __tstate = wxPyBeginAllowThreads();
34102 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34103 wxPyEndAllowThreads(__tstate);
34104 if (PyErr_Occurred()) SWIG_fail;
34105 }
34106 {
34107 resultobj = wxPyMake_wxObject(result, 0);
34108 }
34109 return resultobj;
34110 fail:
34111 return NULL;
34112 }
34113
34114
34115 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34116 PyObject *resultobj = 0;
34117 wxWindow *arg1 = (wxWindow *) 0 ;
34118 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34119 bool result;
34120 void *argp1 = 0 ;
34121 int res1 = 0 ;
34122 void *argp2 = 0 ;
34123 int res2 = 0 ;
34124 PyObject * obj0 = 0 ;
34125 PyObject * obj1 = 0 ;
34126 char * kwnames[] = {
34127 (char *) "self",(char *) "handler", NULL
34128 };
34129
34130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34132 if (!SWIG_IsOK(res1)) {
34133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34134 }
34135 arg1 = reinterpret_cast< wxWindow * >(argp1);
34136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34137 if (!SWIG_IsOK(res2)) {
34138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34139 }
34140 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34141 {
34142 PyThreadState* __tstate = wxPyBeginAllowThreads();
34143 result = (bool)(arg1)->RemoveEventHandler(arg2);
34144 wxPyEndAllowThreads(__tstate);
34145 if (PyErr_Occurred()) SWIG_fail;
34146 }
34147 {
34148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34149 }
34150 return resultobj;
34151 fail:
34152 return NULL;
34153 }
34154
34155
34156 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34157 PyObject *resultobj = 0;
34158 wxWindow *arg1 = (wxWindow *) 0 ;
34159 wxValidator *arg2 = 0 ;
34160 void *argp1 = 0 ;
34161 int res1 = 0 ;
34162 void *argp2 = 0 ;
34163 int res2 = 0 ;
34164 PyObject * obj0 = 0 ;
34165 PyObject * obj1 = 0 ;
34166 char * kwnames[] = {
34167 (char *) "self",(char *) "validator", NULL
34168 };
34169
34170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34172 if (!SWIG_IsOK(res1)) {
34173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34174 }
34175 arg1 = reinterpret_cast< wxWindow * >(argp1);
34176 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34177 if (!SWIG_IsOK(res2)) {
34178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34179 }
34180 if (!argp2) {
34181 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34182 }
34183 arg2 = reinterpret_cast< wxValidator * >(argp2);
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 (arg1)->SetValidator((wxValidator const &)*arg2);
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 resultobj = SWIG_Py_Void();
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34198 PyObject *resultobj = 0;
34199 wxWindow *arg1 = (wxWindow *) 0 ;
34200 wxValidator *result = 0 ;
34201 void *argp1 = 0 ;
34202 int res1 = 0 ;
34203 PyObject *swig_obj[1] ;
34204
34205 if (!args) SWIG_fail;
34206 swig_obj[0] = args;
34207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34210 }
34211 arg1 = reinterpret_cast< wxWindow * >(argp1);
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 result = (wxValidator *)(arg1)->GetValidator();
34215 wxPyEndAllowThreads(__tstate);
34216 if (PyErr_Occurred()) SWIG_fail;
34217 }
34218 {
34219 resultobj = wxPyMake_wxObject(result, (bool)0);
34220 }
34221 return resultobj;
34222 fail:
34223 return NULL;
34224 }
34225
34226
34227 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34228 PyObject *resultobj = 0;
34229 wxWindow *arg1 = (wxWindow *) 0 ;
34230 bool result;
34231 void *argp1 = 0 ;
34232 int res1 = 0 ;
34233 PyObject *swig_obj[1] ;
34234
34235 if (!args) SWIG_fail;
34236 swig_obj[0] = args;
34237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34238 if (!SWIG_IsOK(res1)) {
34239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34240 }
34241 arg1 = reinterpret_cast< wxWindow * >(argp1);
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 result = (bool)(arg1)->Validate();
34245 wxPyEndAllowThreads(__tstate);
34246 if (PyErr_Occurred()) SWIG_fail;
34247 }
34248 {
34249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34250 }
34251 return resultobj;
34252 fail:
34253 return NULL;
34254 }
34255
34256
34257 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34258 PyObject *resultobj = 0;
34259 wxWindow *arg1 = (wxWindow *) 0 ;
34260 bool result;
34261 void *argp1 = 0 ;
34262 int res1 = 0 ;
34263 PyObject *swig_obj[1] ;
34264
34265 if (!args) SWIG_fail;
34266 swig_obj[0] = args;
34267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34268 if (!SWIG_IsOK(res1)) {
34269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34270 }
34271 arg1 = reinterpret_cast< wxWindow * >(argp1);
34272 {
34273 PyThreadState* __tstate = wxPyBeginAllowThreads();
34274 result = (bool)(arg1)->TransferDataToWindow();
34275 wxPyEndAllowThreads(__tstate);
34276 if (PyErr_Occurred()) SWIG_fail;
34277 }
34278 {
34279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34280 }
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34288 PyObject *resultobj = 0;
34289 wxWindow *arg1 = (wxWindow *) 0 ;
34290 bool result;
34291 void *argp1 = 0 ;
34292 int res1 = 0 ;
34293 PyObject *swig_obj[1] ;
34294
34295 if (!args) SWIG_fail;
34296 swig_obj[0] = args;
34297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34298 if (!SWIG_IsOK(res1)) {
34299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34300 }
34301 arg1 = reinterpret_cast< wxWindow * >(argp1);
34302 {
34303 PyThreadState* __tstate = wxPyBeginAllowThreads();
34304 result = (bool)(arg1)->TransferDataFromWindow();
34305 wxPyEndAllowThreads(__tstate);
34306 if (PyErr_Occurred()) SWIG_fail;
34307 }
34308 {
34309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34310 }
34311 return resultobj;
34312 fail:
34313 return NULL;
34314 }
34315
34316
34317 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34318 PyObject *resultobj = 0;
34319 wxWindow *arg1 = (wxWindow *) 0 ;
34320 void *argp1 = 0 ;
34321 int res1 = 0 ;
34322 PyObject *swig_obj[1] ;
34323
34324 if (!args) SWIG_fail;
34325 swig_obj[0] = args;
34326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34329 }
34330 arg1 = reinterpret_cast< wxWindow * >(argp1);
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 (arg1)->InitDialog();
34334 wxPyEndAllowThreads(__tstate);
34335 if (PyErr_Occurred()) SWIG_fail;
34336 }
34337 resultobj = SWIG_Py_Void();
34338 return resultobj;
34339 fail:
34340 return NULL;
34341 }
34342
34343
34344 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34345 PyObject *resultobj = 0;
34346 wxWindow *arg1 = (wxWindow *) 0 ;
34347 wxAcceleratorTable *arg2 = 0 ;
34348 void *argp1 = 0 ;
34349 int res1 = 0 ;
34350 void *argp2 = 0 ;
34351 int res2 = 0 ;
34352 PyObject * obj0 = 0 ;
34353 PyObject * obj1 = 0 ;
34354 char * kwnames[] = {
34355 (char *) "self",(char *) "accel", NULL
34356 };
34357
34358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34360 if (!SWIG_IsOK(res1)) {
34361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34362 }
34363 arg1 = reinterpret_cast< wxWindow * >(argp1);
34364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34365 if (!SWIG_IsOK(res2)) {
34366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34367 }
34368 if (!argp2) {
34369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34370 }
34371 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34372 {
34373 PyThreadState* __tstate = wxPyBeginAllowThreads();
34374 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34375 wxPyEndAllowThreads(__tstate);
34376 if (PyErr_Occurred()) SWIG_fail;
34377 }
34378 resultobj = SWIG_Py_Void();
34379 return resultobj;
34380 fail:
34381 return NULL;
34382 }
34383
34384
34385 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34386 PyObject *resultobj = 0;
34387 wxWindow *arg1 = (wxWindow *) 0 ;
34388 wxAcceleratorTable *result = 0 ;
34389 void *argp1 = 0 ;
34390 int res1 = 0 ;
34391 PyObject *swig_obj[1] ;
34392
34393 if (!args) SWIG_fail;
34394 swig_obj[0] = args;
34395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34398 }
34399 arg1 = reinterpret_cast< wxWindow * >(argp1);
34400 {
34401 PyThreadState* __tstate = wxPyBeginAllowThreads();
34402 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34403 wxPyEndAllowThreads(__tstate);
34404 if (PyErr_Occurred()) SWIG_fail;
34405 }
34406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34407 return resultobj;
34408 fail:
34409 return NULL;
34410 }
34411
34412
34413 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34414 PyObject *resultobj = 0;
34415 wxWindow *arg1 = (wxWindow *) 0 ;
34416 int arg2 ;
34417 int arg3 ;
34418 int arg4 ;
34419 bool result;
34420 void *argp1 = 0 ;
34421 int res1 = 0 ;
34422 int val2 ;
34423 int ecode2 = 0 ;
34424 int val3 ;
34425 int ecode3 = 0 ;
34426 int val4 ;
34427 int ecode4 = 0 ;
34428 PyObject * obj0 = 0 ;
34429 PyObject * obj1 = 0 ;
34430 PyObject * obj2 = 0 ;
34431 PyObject * obj3 = 0 ;
34432 char * kwnames[] = {
34433 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34434 };
34435
34436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34438 if (!SWIG_IsOK(res1)) {
34439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34440 }
34441 arg1 = reinterpret_cast< wxWindow * >(argp1);
34442 ecode2 = SWIG_AsVal_int(obj1, &val2);
34443 if (!SWIG_IsOK(ecode2)) {
34444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34445 }
34446 arg2 = static_cast< int >(val2);
34447 ecode3 = SWIG_AsVal_int(obj2, &val3);
34448 if (!SWIG_IsOK(ecode3)) {
34449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34450 }
34451 arg3 = static_cast< int >(val3);
34452 ecode4 = SWIG_AsVal_int(obj3, &val4);
34453 if (!SWIG_IsOK(ecode4)) {
34454 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34455 }
34456 arg4 = static_cast< int >(val4);
34457 {
34458 PyThreadState* __tstate = wxPyBeginAllowThreads();
34459 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34460 wxPyEndAllowThreads(__tstate);
34461 if (PyErr_Occurred()) SWIG_fail;
34462 }
34463 {
34464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34465 }
34466 return resultobj;
34467 fail:
34468 return NULL;
34469 }
34470
34471
34472 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34473 PyObject *resultobj = 0;
34474 wxWindow *arg1 = (wxWindow *) 0 ;
34475 int arg2 ;
34476 bool result;
34477 void *argp1 = 0 ;
34478 int res1 = 0 ;
34479 int val2 ;
34480 int ecode2 = 0 ;
34481 PyObject * obj0 = 0 ;
34482 PyObject * obj1 = 0 ;
34483 char * kwnames[] = {
34484 (char *) "self",(char *) "hotkeyId", NULL
34485 };
34486
34487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34489 if (!SWIG_IsOK(res1)) {
34490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34491 }
34492 arg1 = reinterpret_cast< wxWindow * >(argp1);
34493 ecode2 = SWIG_AsVal_int(obj1, &val2);
34494 if (!SWIG_IsOK(ecode2)) {
34495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34496 }
34497 arg2 = static_cast< int >(val2);
34498 {
34499 PyThreadState* __tstate = wxPyBeginAllowThreads();
34500 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34501 wxPyEndAllowThreads(__tstate);
34502 if (PyErr_Occurred()) SWIG_fail;
34503 }
34504 {
34505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34506 }
34507 return resultobj;
34508 fail:
34509 return NULL;
34510 }
34511
34512
34513 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34514 PyObject *resultobj = 0;
34515 wxWindow *arg1 = (wxWindow *) 0 ;
34516 wxPoint *arg2 = 0 ;
34517 wxPoint result;
34518 void *argp1 = 0 ;
34519 int res1 = 0 ;
34520 wxPoint temp2 ;
34521 PyObject * obj0 = 0 ;
34522 PyObject * obj1 = 0 ;
34523 char * kwnames[] = {
34524 (char *) "self",(char *) "pt", NULL
34525 };
34526
34527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34529 if (!SWIG_IsOK(res1)) {
34530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34531 }
34532 arg1 = reinterpret_cast< wxWindow * >(argp1);
34533 {
34534 arg2 = &temp2;
34535 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34536 }
34537 {
34538 PyThreadState* __tstate = wxPyBeginAllowThreads();
34539 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34540 wxPyEndAllowThreads(__tstate);
34541 if (PyErr_Occurred()) SWIG_fail;
34542 }
34543 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34544 return resultobj;
34545 fail:
34546 return NULL;
34547 }
34548
34549
34550 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34551 PyObject *resultobj = 0;
34552 wxWindow *arg1 = (wxWindow *) 0 ;
34553 wxSize *arg2 = 0 ;
34554 wxSize result;
34555 void *argp1 = 0 ;
34556 int res1 = 0 ;
34557 wxSize temp2 ;
34558 PyObject * obj0 = 0 ;
34559 PyObject * obj1 = 0 ;
34560 char * kwnames[] = {
34561 (char *) "self",(char *) "sz", NULL
34562 };
34563
34564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34566 if (!SWIG_IsOK(res1)) {
34567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34568 }
34569 arg1 = reinterpret_cast< wxWindow * >(argp1);
34570 {
34571 arg2 = &temp2;
34572 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34573 }
34574 {
34575 PyThreadState* __tstate = wxPyBeginAllowThreads();
34576 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34577 wxPyEndAllowThreads(__tstate);
34578 if (PyErr_Occurred()) SWIG_fail;
34579 }
34580 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34581 return resultobj;
34582 fail:
34583 return NULL;
34584 }
34585
34586
34587 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34588 PyObject *resultobj = 0;
34589 wxWindow *arg1 = (wxWindow *) 0 ;
34590 wxPoint *arg2 = 0 ;
34591 wxPoint result;
34592 void *argp1 = 0 ;
34593 int res1 = 0 ;
34594 wxPoint temp2 ;
34595 PyObject * obj0 = 0 ;
34596 PyObject * obj1 = 0 ;
34597 char * kwnames[] = {
34598 (char *) "self",(char *) "pt", NULL
34599 };
34600
34601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34603 if (!SWIG_IsOK(res1)) {
34604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34605 }
34606 arg1 = reinterpret_cast< wxWindow * >(argp1);
34607 {
34608 arg2 = &temp2;
34609 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34610 }
34611 {
34612 PyThreadState* __tstate = wxPyBeginAllowThreads();
34613 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34614 wxPyEndAllowThreads(__tstate);
34615 if (PyErr_Occurred()) SWIG_fail;
34616 }
34617 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34618 return resultobj;
34619 fail:
34620 return NULL;
34621 }
34622
34623
34624 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34625 PyObject *resultobj = 0;
34626 wxWindow *arg1 = (wxWindow *) 0 ;
34627 wxSize *arg2 = 0 ;
34628 wxSize result;
34629 void *argp1 = 0 ;
34630 int res1 = 0 ;
34631 wxSize temp2 ;
34632 PyObject * obj0 = 0 ;
34633 PyObject * obj1 = 0 ;
34634 char * kwnames[] = {
34635 (char *) "self",(char *) "sz", NULL
34636 };
34637
34638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34640 if (!SWIG_IsOK(res1)) {
34641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34642 }
34643 arg1 = reinterpret_cast< wxWindow * >(argp1);
34644 {
34645 arg2 = &temp2;
34646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34647 }
34648 {
34649 PyThreadState* __tstate = wxPyBeginAllowThreads();
34650 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34651 wxPyEndAllowThreads(__tstate);
34652 if (PyErr_Occurred()) SWIG_fail;
34653 }
34654 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34655 return resultobj;
34656 fail:
34657 return NULL;
34658 }
34659
34660
34661 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34662 PyObject *resultobj = 0;
34663 wxWindow *arg1 = (wxWindow *) 0 ;
34664 wxPoint *arg2 = 0 ;
34665 wxPoint result;
34666 void *argp1 = 0 ;
34667 int res1 = 0 ;
34668 wxPoint temp2 ;
34669 PyObject * obj0 = 0 ;
34670 PyObject * obj1 = 0 ;
34671 char * kwnames[] = {
34672 (char *) "self",(char *) "pt", NULL
34673 };
34674
34675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34677 if (!SWIG_IsOK(res1)) {
34678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34679 }
34680 arg1 = reinterpret_cast< wxWindow * >(argp1);
34681 {
34682 arg2 = &temp2;
34683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34684 }
34685 {
34686 PyThreadState* __tstate = wxPyBeginAllowThreads();
34687 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34688 wxPyEndAllowThreads(__tstate);
34689 if (PyErr_Occurred()) SWIG_fail;
34690 }
34691 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34692 return resultobj;
34693 fail:
34694 return NULL;
34695 }
34696
34697
34698 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34699 PyObject *resultobj = 0;
34700 wxWindow *arg1 = (wxWindow *) 0 ;
34701 wxSize *arg2 = 0 ;
34702 wxSize result;
34703 void *argp1 = 0 ;
34704 int res1 = 0 ;
34705 wxSize temp2 ;
34706 PyObject * obj0 = 0 ;
34707 PyObject * obj1 = 0 ;
34708 char * kwnames[] = {
34709 (char *) "self",(char *) "sz", NULL
34710 };
34711
34712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34714 if (!SWIG_IsOK(res1)) {
34715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34716 }
34717 arg1 = reinterpret_cast< wxWindow * >(argp1);
34718 {
34719 arg2 = &temp2;
34720 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34721 }
34722 {
34723 PyThreadState* __tstate = wxPyBeginAllowThreads();
34724 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34725 wxPyEndAllowThreads(__tstate);
34726 if (PyErr_Occurred()) SWIG_fail;
34727 }
34728 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34729 return resultobj;
34730 fail:
34731 return NULL;
34732 }
34733
34734
34735 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34736 PyObject *resultobj = 0;
34737 wxWindow *arg1 = (wxWindow *) 0 ;
34738 int arg2 ;
34739 int arg3 ;
34740 void *argp1 = 0 ;
34741 int res1 = 0 ;
34742 int val2 ;
34743 int ecode2 = 0 ;
34744 int val3 ;
34745 int ecode3 = 0 ;
34746 PyObject * obj0 = 0 ;
34747 PyObject * obj1 = 0 ;
34748 PyObject * obj2 = 0 ;
34749 char * kwnames[] = {
34750 (char *) "self",(char *) "x",(char *) "y", NULL
34751 };
34752
34753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34755 if (!SWIG_IsOK(res1)) {
34756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34757 }
34758 arg1 = reinterpret_cast< wxWindow * >(argp1);
34759 ecode2 = SWIG_AsVal_int(obj1, &val2);
34760 if (!SWIG_IsOK(ecode2)) {
34761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34762 }
34763 arg2 = static_cast< int >(val2);
34764 ecode3 = SWIG_AsVal_int(obj2, &val3);
34765 if (!SWIG_IsOK(ecode3)) {
34766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34767 }
34768 arg3 = static_cast< int >(val3);
34769 {
34770 PyThreadState* __tstate = wxPyBeginAllowThreads();
34771 (arg1)->WarpPointer(arg2,arg3);
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 resultobj = SWIG_Py_Void();
34776 return resultobj;
34777 fail:
34778 return NULL;
34779 }
34780
34781
34782 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34783 PyObject *resultobj = 0;
34784 wxWindow *arg1 = (wxWindow *) 0 ;
34785 void *argp1 = 0 ;
34786 int res1 = 0 ;
34787 PyObject *swig_obj[1] ;
34788
34789 if (!args) SWIG_fail;
34790 swig_obj[0] = args;
34791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34792 if (!SWIG_IsOK(res1)) {
34793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34794 }
34795 arg1 = reinterpret_cast< wxWindow * >(argp1);
34796 {
34797 PyThreadState* __tstate = wxPyBeginAllowThreads();
34798 (arg1)->CaptureMouse();
34799 wxPyEndAllowThreads(__tstate);
34800 if (PyErr_Occurred()) SWIG_fail;
34801 }
34802 resultobj = SWIG_Py_Void();
34803 return resultobj;
34804 fail:
34805 return NULL;
34806 }
34807
34808
34809 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34810 PyObject *resultobj = 0;
34811 wxWindow *arg1 = (wxWindow *) 0 ;
34812 void *argp1 = 0 ;
34813 int res1 = 0 ;
34814 PyObject *swig_obj[1] ;
34815
34816 if (!args) SWIG_fail;
34817 swig_obj[0] = args;
34818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34819 if (!SWIG_IsOK(res1)) {
34820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34821 }
34822 arg1 = reinterpret_cast< wxWindow * >(argp1);
34823 {
34824 PyThreadState* __tstate = wxPyBeginAllowThreads();
34825 (arg1)->ReleaseMouse();
34826 wxPyEndAllowThreads(__tstate);
34827 if (PyErr_Occurred()) SWIG_fail;
34828 }
34829 resultobj = SWIG_Py_Void();
34830 return resultobj;
34831 fail:
34832 return NULL;
34833 }
34834
34835
34836 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34837 PyObject *resultobj = 0;
34838 wxWindow *result = 0 ;
34839
34840 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34841 {
34842 if (!wxPyCheckForApp()) SWIG_fail;
34843 PyThreadState* __tstate = wxPyBeginAllowThreads();
34844 result = (wxWindow *)wxWindow::GetCapture();
34845 wxPyEndAllowThreads(__tstate);
34846 if (PyErr_Occurred()) SWIG_fail;
34847 }
34848 {
34849 resultobj = wxPyMake_wxObject(result, 0);
34850 }
34851 return resultobj;
34852 fail:
34853 return NULL;
34854 }
34855
34856
34857 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34858 PyObject *resultobj = 0;
34859 wxWindow *arg1 = (wxWindow *) 0 ;
34860 bool result;
34861 void *argp1 = 0 ;
34862 int res1 = 0 ;
34863 PyObject *swig_obj[1] ;
34864
34865 if (!args) SWIG_fail;
34866 swig_obj[0] = args;
34867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34868 if (!SWIG_IsOK(res1)) {
34869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34870 }
34871 arg1 = reinterpret_cast< wxWindow * >(argp1);
34872 {
34873 PyThreadState* __tstate = wxPyBeginAllowThreads();
34874 result = (bool)((wxWindow const *)arg1)->HasCapture();
34875 wxPyEndAllowThreads(__tstate);
34876 if (PyErr_Occurred()) SWIG_fail;
34877 }
34878 {
34879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34880 }
34881 return resultobj;
34882 fail:
34883 return NULL;
34884 }
34885
34886
34887 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34888 PyObject *resultobj = 0;
34889 wxWindow *arg1 = (wxWindow *) 0 ;
34890 bool arg2 = (bool) true ;
34891 wxRect *arg3 = (wxRect *) NULL ;
34892 void *argp1 = 0 ;
34893 int res1 = 0 ;
34894 bool val2 ;
34895 int ecode2 = 0 ;
34896 void *argp3 = 0 ;
34897 int res3 = 0 ;
34898 PyObject * obj0 = 0 ;
34899 PyObject * obj1 = 0 ;
34900 PyObject * obj2 = 0 ;
34901 char * kwnames[] = {
34902 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34903 };
34904
34905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34907 if (!SWIG_IsOK(res1)) {
34908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34909 }
34910 arg1 = reinterpret_cast< wxWindow * >(argp1);
34911 if (obj1) {
34912 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34913 if (!SWIG_IsOK(ecode2)) {
34914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34915 }
34916 arg2 = static_cast< bool >(val2);
34917 }
34918 if (obj2) {
34919 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34920 if (!SWIG_IsOK(res3)) {
34921 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34922 }
34923 arg3 = reinterpret_cast< wxRect * >(argp3);
34924 }
34925 {
34926 PyThreadState* __tstate = wxPyBeginAllowThreads();
34927 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34928 wxPyEndAllowThreads(__tstate);
34929 if (PyErr_Occurred()) SWIG_fail;
34930 }
34931 resultobj = SWIG_Py_Void();
34932 return resultobj;
34933 fail:
34934 return NULL;
34935 }
34936
34937
34938 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34939 PyObject *resultobj = 0;
34940 wxWindow *arg1 = (wxWindow *) 0 ;
34941 wxRect *arg2 = 0 ;
34942 bool arg3 = (bool) true ;
34943 void *argp1 = 0 ;
34944 int res1 = 0 ;
34945 wxRect temp2 ;
34946 bool val3 ;
34947 int ecode3 = 0 ;
34948 PyObject * obj0 = 0 ;
34949 PyObject * obj1 = 0 ;
34950 PyObject * obj2 = 0 ;
34951 char * kwnames[] = {
34952 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34953 };
34954
34955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34957 if (!SWIG_IsOK(res1)) {
34958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34959 }
34960 arg1 = reinterpret_cast< wxWindow * >(argp1);
34961 {
34962 arg2 = &temp2;
34963 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34964 }
34965 if (obj2) {
34966 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34967 if (!SWIG_IsOK(ecode3)) {
34968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34969 }
34970 arg3 = static_cast< bool >(val3);
34971 }
34972 {
34973 PyThreadState* __tstate = wxPyBeginAllowThreads();
34974 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34975 wxPyEndAllowThreads(__tstate);
34976 if (PyErr_Occurred()) SWIG_fail;
34977 }
34978 resultobj = SWIG_Py_Void();
34979 return resultobj;
34980 fail:
34981 return NULL;
34982 }
34983
34984
34985 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34986 PyObject *resultobj = 0;
34987 wxWindow *arg1 = (wxWindow *) 0 ;
34988 void *argp1 = 0 ;
34989 int res1 = 0 ;
34990 PyObject *swig_obj[1] ;
34991
34992 if (!args) SWIG_fail;
34993 swig_obj[0] = args;
34994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34995 if (!SWIG_IsOK(res1)) {
34996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34997 }
34998 arg1 = reinterpret_cast< wxWindow * >(argp1);
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 (arg1)->Update();
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 resultobj = SWIG_Py_Void();
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35013 PyObject *resultobj = 0;
35014 wxWindow *arg1 = (wxWindow *) 0 ;
35015 void *argp1 = 0 ;
35016 int res1 = 0 ;
35017 PyObject *swig_obj[1] ;
35018
35019 if (!args) SWIG_fail;
35020 swig_obj[0] = args;
35021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35022 if (!SWIG_IsOK(res1)) {
35023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35024 }
35025 arg1 = reinterpret_cast< wxWindow * >(argp1);
35026 {
35027 PyThreadState* __tstate = wxPyBeginAllowThreads();
35028 (arg1)->ClearBackground();
35029 wxPyEndAllowThreads(__tstate);
35030 if (PyErr_Occurred()) SWIG_fail;
35031 }
35032 resultobj = SWIG_Py_Void();
35033 return resultobj;
35034 fail:
35035 return NULL;
35036 }
35037
35038
35039 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35040 PyObject *resultobj = 0;
35041 wxWindow *arg1 = (wxWindow *) 0 ;
35042 void *argp1 = 0 ;
35043 int res1 = 0 ;
35044 PyObject *swig_obj[1] ;
35045
35046 if (!args) SWIG_fail;
35047 swig_obj[0] = args;
35048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35049 if (!SWIG_IsOK(res1)) {
35050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35051 }
35052 arg1 = reinterpret_cast< wxWindow * >(argp1);
35053 {
35054 PyThreadState* __tstate = wxPyBeginAllowThreads();
35055 (arg1)->Freeze();
35056 wxPyEndAllowThreads(__tstate);
35057 if (PyErr_Occurred()) SWIG_fail;
35058 }
35059 resultobj = SWIG_Py_Void();
35060 return resultobj;
35061 fail:
35062 return NULL;
35063 }
35064
35065
35066 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35067 PyObject *resultobj = 0;
35068 wxWindow *arg1 = (wxWindow *) 0 ;
35069 bool result;
35070 void *argp1 = 0 ;
35071 int res1 = 0 ;
35072 PyObject *swig_obj[1] ;
35073
35074 if (!args) SWIG_fail;
35075 swig_obj[0] = args;
35076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35077 if (!SWIG_IsOK(res1)) {
35078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35079 }
35080 arg1 = reinterpret_cast< wxWindow * >(argp1);
35081 {
35082 PyThreadState* __tstate = wxPyBeginAllowThreads();
35083 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35084 wxPyEndAllowThreads(__tstate);
35085 if (PyErr_Occurred()) SWIG_fail;
35086 }
35087 {
35088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35089 }
35090 return resultobj;
35091 fail:
35092 return NULL;
35093 }
35094
35095
35096 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35097 PyObject *resultobj = 0;
35098 wxWindow *arg1 = (wxWindow *) 0 ;
35099 void *argp1 = 0 ;
35100 int res1 = 0 ;
35101 PyObject *swig_obj[1] ;
35102
35103 if (!args) SWIG_fail;
35104 swig_obj[0] = args;
35105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35106 if (!SWIG_IsOK(res1)) {
35107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35108 }
35109 arg1 = reinterpret_cast< wxWindow * >(argp1);
35110 {
35111 PyThreadState* __tstate = wxPyBeginAllowThreads();
35112 (arg1)->Thaw();
35113 wxPyEndAllowThreads(__tstate);
35114 if (PyErr_Occurred()) SWIG_fail;
35115 }
35116 resultobj = SWIG_Py_Void();
35117 return resultobj;
35118 fail:
35119 return NULL;
35120 }
35121
35122
35123 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35124 PyObject *resultobj = 0;
35125 wxWindow *arg1 = (wxWindow *) 0 ;
35126 wxDC *arg2 = 0 ;
35127 void *argp1 = 0 ;
35128 int res1 = 0 ;
35129 void *argp2 = 0 ;
35130 int res2 = 0 ;
35131 PyObject * obj0 = 0 ;
35132 PyObject * obj1 = 0 ;
35133 char * kwnames[] = {
35134 (char *) "self",(char *) "dc", NULL
35135 };
35136
35137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35139 if (!SWIG_IsOK(res1)) {
35140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35141 }
35142 arg1 = reinterpret_cast< wxWindow * >(argp1);
35143 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35144 if (!SWIG_IsOK(res2)) {
35145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35146 }
35147 if (!argp2) {
35148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35149 }
35150 arg2 = reinterpret_cast< wxDC * >(argp2);
35151 {
35152 PyThreadState* __tstate = wxPyBeginAllowThreads();
35153 (arg1)->PrepareDC(*arg2);
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 resultobj = SWIG_Py_Void();
35158 return resultobj;
35159 fail:
35160 return NULL;
35161 }
35162
35163
35164 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35165 PyObject *resultobj = 0;
35166 wxWindow *arg1 = (wxWindow *) 0 ;
35167 wxRegion *result = 0 ;
35168 void *argp1 = 0 ;
35169 int res1 = 0 ;
35170 PyObject *swig_obj[1] ;
35171
35172 if (!args) SWIG_fail;
35173 swig_obj[0] = args;
35174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35175 if (!SWIG_IsOK(res1)) {
35176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35177 }
35178 arg1 = reinterpret_cast< wxWindow * >(argp1);
35179 {
35180 PyThreadState* __tstate = wxPyBeginAllowThreads();
35181 {
35182 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35183 result = (wxRegion *) &_result_ref;
35184 }
35185 wxPyEndAllowThreads(__tstate);
35186 if (PyErr_Occurred()) SWIG_fail;
35187 }
35188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35189 return resultobj;
35190 fail:
35191 return NULL;
35192 }
35193
35194
35195 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35196 PyObject *resultobj = 0;
35197 wxWindow *arg1 = (wxWindow *) 0 ;
35198 wxRect result;
35199 void *argp1 = 0 ;
35200 int res1 = 0 ;
35201 PyObject *swig_obj[1] ;
35202
35203 if (!args) SWIG_fail;
35204 swig_obj[0] = args;
35205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35206 if (!SWIG_IsOK(res1)) {
35207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35208 }
35209 arg1 = reinterpret_cast< wxWindow * >(argp1);
35210 {
35211 PyThreadState* __tstate = wxPyBeginAllowThreads();
35212 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35213 wxPyEndAllowThreads(__tstate);
35214 if (PyErr_Occurred()) SWIG_fail;
35215 }
35216 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35217 return resultobj;
35218 fail:
35219 return NULL;
35220 }
35221
35222
35223 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35224 PyObject *resultobj = 0;
35225 wxWindow *arg1 = (wxWindow *) 0 ;
35226 int arg2 ;
35227 int arg3 ;
35228 int arg4 = (int) 1 ;
35229 int arg5 = (int) 1 ;
35230 bool result;
35231 void *argp1 = 0 ;
35232 int res1 = 0 ;
35233 int val2 ;
35234 int ecode2 = 0 ;
35235 int val3 ;
35236 int ecode3 = 0 ;
35237 int val4 ;
35238 int ecode4 = 0 ;
35239 int val5 ;
35240 int ecode5 = 0 ;
35241 PyObject * obj0 = 0 ;
35242 PyObject * obj1 = 0 ;
35243 PyObject * obj2 = 0 ;
35244 PyObject * obj3 = 0 ;
35245 PyObject * obj4 = 0 ;
35246 char * kwnames[] = {
35247 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35248 };
35249
35250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35252 if (!SWIG_IsOK(res1)) {
35253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35254 }
35255 arg1 = reinterpret_cast< wxWindow * >(argp1);
35256 ecode2 = SWIG_AsVal_int(obj1, &val2);
35257 if (!SWIG_IsOK(ecode2)) {
35258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35259 }
35260 arg2 = static_cast< int >(val2);
35261 ecode3 = SWIG_AsVal_int(obj2, &val3);
35262 if (!SWIG_IsOK(ecode3)) {
35263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35264 }
35265 arg3 = static_cast< int >(val3);
35266 if (obj3) {
35267 ecode4 = SWIG_AsVal_int(obj3, &val4);
35268 if (!SWIG_IsOK(ecode4)) {
35269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35270 }
35271 arg4 = static_cast< int >(val4);
35272 }
35273 if (obj4) {
35274 ecode5 = SWIG_AsVal_int(obj4, &val5);
35275 if (!SWIG_IsOK(ecode5)) {
35276 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35277 }
35278 arg5 = static_cast< int >(val5);
35279 }
35280 {
35281 PyThreadState* __tstate = wxPyBeginAllowThreads();
35282 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35283 wxPyEndAllowThreads(__tstate);
35284 if (PyErr_Occurred()) SWIG_fail;
35285 }
35286 {
35287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35288 }
35289 return resultobj;
35290 fail:
35291 return NULL;
35292 }
35293
35294
35295 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35296 PyObject *resultobj = 0;
35297 wxWindow *arg1 = (wxWindow *) 0 ;
35298 wxPoint *arg2 = 0 ;
35299 bool result;
35300 void *argp1 = 0 ;
35301 int res1 = 0 ;
35302 wxPoint temp2 ;
35303 PyObject * obj0 = 0 ;
35304 PyObject * obj1 = 0 ;
35305 char * kwnames[] = {
35306 (char *) "self",(char *) "pt", NULL
35307 };
35308
35309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35311 if (!SWIG_IsOK(res1)) {
35312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35313 }
35314 arg1 = reinterpret_cast< wxWindow * >(argp1);
35315 {
35316 arg2 = &temp2;
35317 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35318 }
35319 {
35320 PyThreadState* __tstate = wxPyBeginAllowThreads();
35321 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35322 wxPyEndAllowThreads(__tstate);
35323 if (PyErr_Occurred()) SWIG_fail;
35324 }
35325 {
35326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35327 }
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35335 PyObject *resultobj = 0;
35336 wxWindow *arg1 = (wxWindow *) 0 ;
35337 wxRect *arg2 = 0 ;
35338 bool result;
35339 void *argp1 = 0 ;
35340 int res1 = 0 ;
35341 wxRect temp2 ;
35342 PyObject * obj0 = 0 ;
35343 PyObject * obj1 = 0 ;
35344 char * kwnames[] = {
35345 (char *) "self",(char *) "rect", NULL
35346 };
35347
35348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35350 if (!SWIG_IsOK(res1)) {
35351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35352 }
35353 arg1 = reinterpret_cast< wxWindow * >(argp1);
35354 {
35355 arg2 = &temp2;
35356 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35357 }
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 {
35365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35366 }
35367 return resultobj;
35368 fail:
35369 return NULL;
35370 }
35371
35372
35373 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35374 PyObject *resultobj = 0;
35375 wxWindow *arg1 = (wxWindow *) 0 ;
35376 SwigValueWrapper<wxVisualAttributes > result;
35377 void *argp1 = 0 ;
35378 int res1 = 0 ;
35379 PyObject *swig_obj[1] ;
35380
35381 if (!args) SWIG_fail;
35382 swig_obj[0] = args;
35383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35384 if (!SWIG_IsOK(res1)) {
35385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35386 }
35387 arg1 = reinterpret_cast< wxWindow * >(argp1);
35388 {
35389 PyThreadState* __tstate = wxPyBeginAllowThreads();
35390 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35391 wxPyEndAllowThreads(__tstate);
35392 if (PyErr_Occurred()) SWIG_fail;
35393 }
35394 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35395 return resultobj;
35396 fail:
35397 return NULL;
35398 }
35399
35400
35401 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35402 PyObject *resultobj = 0;
35403 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35404 SwigValueWrapper<wxVisualAttributes > result;
35405 int val1 ;
35406 int ecode1 = 0 ;
35407 PyObject * obj0 = 0 ;
35408 char * kwnames[] = {
35409 (char *) "variant", NULL
35410 };
35411
35412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35413 if (obj0) {
35414 ecode1 = SWIG_AsVal_int(obj0, &val1);
35415 if (!SWIG_IsOK(ecode1)) {
35416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35417 }
35418 arg1 = static_cast< wxWindowVariant >(val1);
35419 }
35420 {
35421 if (!wxPyCheckForApp()) SWIG_fail;
35422 PyThreadState* __tstate = wxPyBeginAllowThreads();
35423 result = wxWindow::GetClassDefaultAttributes(arg1);
35424 wxPyEndAllowThreads(__tstate);
35425 if (PyErr_Occurred()) SWIG_fail;
35426 }
35427 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35428 return resultobj;
35429 fail:
35430 return NULL;
35431 }
35432
35433
35434 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35435 PyObject *resultobj = 0;
35436 wxWindow *arg1 = (wxWindow *) 0 ;
35437 wxColour *arg2 = 0 ;
35438 bool result;
35439 void *argp1 = 0 ;
35440 int res1 = 0 ;
35441 wxColour temp2 ;
35442 PyObject * obj0 = 0 ;
35443 PyObject * obj1 = 0 ;
35444 char * kwnames[] = {
35445 (char *) "self",(char *) "colour", NULL
35446 };
35447
35448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35450 if (!SWIG_IsOK(res1)) {
35451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35452 }
35453 arg1 = reinterpret_cast< wxWindow * >(argp1);
35454 {
35455 arg2 = &temp2;
35456 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35457 }
35458 {
35459 PyThreadState* __tstate = wxPyBeginAllowThreads();
35460 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35461 wxPyEndAllowThreads(__tstate);
35462 if (PyErr_Occurred()) SWIG_fail;
35463 }
35464 {
35465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35466 }
35467 return resultobj;
35468 fail:
35469 return NULL;
35470 }
35471
35472
35473 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35474 PyObject *resultobj = 0;
35475 wxWindow *arg1 = (wxWindow *) 0 ;
35476 wxColour *arg2 = 0 ;
35477 void *argp1 = 0 ;
35478 int res1 = 0 ;
35479 wxColour temp2 ;
35480 PyObject * obj0 = 0 ;
35481 PyObject * obj1 = 0 ;
35482 char * kwnames[] = {
35483 (char *) "self",(char *) "colour", NULL
35484 };
35485
35486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35488 if (!SWIG_IsOK(res1)) {
35489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35490 }
35491 arg1 = reinterpret_cast< wxWindow * >(argp1);
35492 {
35493 arg2 = &temp2;
35494 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35495 }
35496 {
35497 PyThreadState* __tstate = wxPyBeginAllowThreads();
35498 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35499 wxPyEndAllowThreads(__tstate);
35500 if (PyErr_Occurred()) SWIG_fail;
35501 }
35502 resultobj = SWIG_Py_Void();
35503 return resultobj;
35504 fail:
35505 return NULL;
35506 }
35507
35508
35509 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35510 PyObject *resultobj = 0;
35511 wxWindow *arg1 = (wxWindow *) 0 ;
35512 wxColour *arg2 = 0 ;
35513 bool result;
35514 void *argp1 = 0 ;
35515 int res1 = 0 ;
35516 wxColour temp2 ;
35517 PyObject * obj0 = 0 ;
35518 PyObject * obj1 = 0 ;
35519 char * kwnames[] = {
35520 (char *) "self",(char *) "colour", NULL
35521 };
35522
35523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35525 if (!SWIG_IsOK(res1)) {
35526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35527 }
35528 arg1 = reinterpret_cast< wxWindow * >(argp1);
35529 {
35530 arg2 = &temp2;
35531 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35532 }
35533 {
35534 PyThreadState* __tstate = wxPyBeginAllowThreads();
35535 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35536 wxPyEndAllowThreads(__tstate);
35537 if (PyErr_Occurred()) SWIG_fail;
35538 }
35539 {
35540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35541 }
35542 return resultobj;
35543 fail:
35544 return NULL;
35545 }
35546
35547
35548 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35549 PyObject *resultobj = 0;
35550 wxWindow *arg1 = (wxWindow *) 0 ;
35551 wxColour *arg2 = 0 ;
35552 void *argp1 = 0 ;
35553 int res1 = 0 ;
35554 wxColour temp2 ;
35555 PyObject * obj0 = 0 ;
35556 PyObject * obj1 = 0 ;
35557 char * kwnames[] = {
35558 (char *) "self",(char *) "colour", NULL
35559 };
35560
35561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35563 if (!SWIG_IsOK(res1)) {
35564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35565 }
35566 arg1 = reinterpret_cast< wxWindow * >(argp1);
35567 {
35568 arg2 = &temp2;
35569 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35570 }
35571 {
35572 PyThreadState* __tstate = wxPyBeginAllowThreads();
35573 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35574 wxPyEndAllowThreads(__tstate);
35575 if (PyErr_Occurred()) SWIG_fail;
35576 }
35577 resultobj = SWIG_Py_Void();
35578 return resultobj;
35579 fail:
35580 return NULL;
35581 }
35582
35583
35584 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35585 PyObject *resultobj = 0;
35586 wxWindow *arg1 = (wxWindow *) 0 ;
35587 wxColour result;
35588 void *argp1 = 0 ;
35589 int res1 = 0 ;
35590 PyObject *swig_obj[1] ;
35591
35592 if (!args) SWIG_fail;
35593 swig_obj[0] = args;
35594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35595 if (!SWIG_IsOK(res1)) {
35596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35597 }
35598 arg1 = reinterpret_cast< wxWindow * >(argp1);
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35602 wxPyEndAllowThreads(__tstate);
35603 if (PyErr_Occurred()) SWIG_fail;
35604 }
35605 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35606 return resultobj;
35607 fail:
35608 return NULL;
35609 }
35610
35611
35612 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35613 PyObject *resultobj = 0;
35614 wxWindow *arg1 = (wxWindow *) 0 ;
35615 wxColour result;
35616 void *argp1 = 0 ;
35617 int res1 = 0 ;
35618 PyObject *swig_obj[1] ;
35619
35620 if (!args) SWIG_fail;
35621 swig_obj[0] = args;
35622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35623 if (!SWIG_IsOK(res1)) {
35624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35625 }
35626 arg1 = reinterpret_cast< wxWindow * >(argp1);
35627 {
35628 PyThreadState* __tstate = wxPyBeginAllowThreads();
35629 result = ((wxWindow const *)arg1)->GetForegroundColour();
35630 wxPyEndAllowThreads(__tstate);
35631 if (PyErr_Occurred()) SWIG_fail;
35632 }
35633 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35634 return resultobj;
35635 fail:
35636 return NULL;
35637 }
35638
35639
35640 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35641 PyObject *resultobj = 0;
35642 wxWindow *arg1 = (wxWindow *) 0 ;
35643 bool result;
35644 void *argp1 = 0 ;
35645 int res1 = 0 ;
35646 PyObject *swig_obj[1] ;
35647
35648 if (!args) SWIG_fail;
35649 swig_obj[0] = args;
35650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35651 if (!SWIG_IsOK(res1)) {
35652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35653 }
35654 arg1 = reinterpret_cast< wxWindow * >(argp1);
35655 {
35656 PyThreadState* __tstate = wxPyBeginAllowThreads();
35657 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35658 wxPyEndAllowThreads(__tstate);
35659 if (PyErr_Occurred()) SWIG_fail;
35660 }
35661 {
35662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35663 }
35664 return resultobj;
35665 fail:
35666 return NULL;
35667 }
35668
35669
35670 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35671 PyObject *resultobj = 0;
35672 wxWindow *arg1 = (wxWindow *) 0 ;
35673 bool result;
35674 void *argp1 = 0 ;
35675 int res1 = 0 ;
35676 PyObject *swig_obj[1] ;
35677
35678 if (!args) SWIG_fail;
35679 swig_obj[0] = args;
35680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35681 if (!SWIG_IsOK(res1)) {
35682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35683 }
35684 arg1 = reinterpret_cast< wxWindow * >(argp1);
35685 {
35686 PyThreadState* __tstate = wxPyBeginAllowThreads();
35687 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35688 wxPyEndAllowThreads(__tstate);
35689 if (PyErr_Occurred()) SWIG_fail;
35690 }
35691 {
35692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35693 }
35694 return resultobj;
35695 fail:
35696 return NULL;
35697 }
35698
35699
35700 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35701 PyObject *resultobj = 0;
35702 wxWindow *arg1 = (wxWindow *) 0 ;
35703 wxBackgroundStyle arg2 ;
35704 bool result;
35705 void *argp1 = 0 ;
35706 int res1 = 0 ;
35707 int val2 ;
35708 int ecode2 = 0 ;
35709 PyObject * obj0 = 0 ;
35710 PyObject * obj1 = 0 ;
35711 char * kwnames[] = {
35712 (char *) "self",(char *) "style", NULL
35713 };
35714
35715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35717 if (!SWIG_IsOK(res1)) {
35718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35719 }
35720 arg1 = reinterpret_cast< wxWindow * >(argp1);
35721 ecode2 = SWIG_AsVal_int(obj1, &val2);
35722 if (!SWIG_IsOK(ecode2)) {
35723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35724 }
35725 arg2 = static_cast< wxBackgroundStyle >(val2);
35726 {
35727 PyThreadState* __tstate = wxPyBeginAllowThreads();
35728 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35729 wxPyEndAllowThreads(__tstate);
35730 if (PyErr_Occurred()) SWIG_fail;
35731 }
35732 {
35733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35734 }
35735 return resultobj;
35736 fail:
35737 return NULL;
35738 }
35739
35740
35741 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35742 PyObject *resultobj = 0;
35743 wxWindow *arg1 = (wxWindow *) 0 ;
35744 wxBackgroundStyle result;
35745 void *argp1 = 0 ;
35746 int res1 = 0 ;
35747 PyObject *swig_obj[1] ;
35748
35749 if (!args) SWIG_fail;
35750 swig_obj[0] = args;
35751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35752 if (!SWIG_IsOK(res1)) {
35753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35754 }
35755 arg1 = reinterpret_cast< wxWindow * >(argp1);
35756 {
35757 PyThreadState* __tstate = wxPyBeginAllowThreads();
35758 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35759 wxPyEndAllowThreads(__tstate);
35760 if (PyErr_Occurred()) SWIG_fail;
35761 }
35762 resultobj = SWIG_From_int(static_cast< int >(result));
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35770 PyObject *resultobj = 0;
35771 wxWindow *arg1 = (wxWindow *) 0 ;
35772 bool result;
35773 void *argp1 = 0 ;
35774 int res1 = 0 ;
35775 PyObject *swig_obj[1] ;
35776
35777 if (!args) SWIG_fail;
35778 swig_obj[0] = args;
35779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35780 if (!SWIG_IsOK(res1)) {
35781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35782 }
35783 arg1 = reinterpret_cast< wxWindow * >(argp1);
35784 {
35785 PyThreadState* __tstate = wxPyBeginAllowThreads();
35786 result = (bool)(arg1)->HasTransparentBackground();
35787 wxPyEndAllowThreads(__tstate);
35788 if (PyErr_Occurred()) SWIG_fail;
35789 }
35790 {
35791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35792 }
35793 return resultobj;
35794 fail:
35795 return NULL;
35796 }
35797
35798
35799 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35800 PyObject *resultobj = 0;
35801 wxWindow *arg1 = (wxWindow *) 0 ;
35802 wxCursor *arg2 = 0 ;
35803 bool result;
35804 void *argp1 = 0 ;
35805 int res1 = 0 ;
35806 void *argp2 = 0 ;
35807 int res2 = 0 ;
35808 PyObject * obj0 = 0 ;
35809 PyObject * obj1 = 0 ;
35810 char * kwnames[] = {
35811 (char *) "self",(char *) "cursor", NULL
35812 };
35813
35814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35816 if (!SWIG_IsOK(res1)) {
35817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35818 }
35819 arg1 = reinterpret_cast< wxWindow * >(argp1);
35820 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35821 if (!SWIG_IsOK(res2)) {
35822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35823 }
35824 if (!argp2) {
35825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35826 }
35827 arg2 = reinterpret_cast< wxCursor * >(argp2);
35828 {
35829 PyThreadState* __tstate = wxPyBeginAllowThreads();
35830 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35831 wxPyEndAllowThreads(__tstate);
35832 if (PyErr_Occurred()) SWIG_fail;
35833 }
35834 {
35835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35836 }
35837 return resultobj;
35838 fail:
35839 return NULL;
35840 }
35841
35842
35843 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35844 PyObject *resultobj = 0;
35845 wxWindow *arg1 = (wxWindow *) 0 ;
35846 wxCursor result;
35847 void *argp1 = 0 ;
35848 int res1 = 0 ;
35849 PyObject *swig_obj[1] ;
35850
35851 if (!args) SWIG_fail;
35852 swig_obj[0] = args;
35853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35854 if (!SWIG_IsOK(res1)) {
35855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35856 }
35857 arg1 = reinterpret_cast< wxWindow * >(argp1);
35858 {
35859 PyThreadState* __tstate = wxPyBeginAllowThreads();
35860 result = (arg1)->GetCursor();
35861 wxPyEndAllowThreads(__tstate);
35862 if (PyErr_Occurred()) SWIG_fail;
35863 }
35864 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35865 return resultobj;
35866 fail:
35867 return NULL;
35868 }
35869
35870
35871 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35872 PyObject *resultobj = 0;
35873 wxWindow *arg1 = (wxWindow *) 0 ;
35874 wxFont *arg2 = 0 ;
35875 bool result;
35876 void *argp1 = 0 ;
35877 int res1 = 0 ;
35878 void *argp2 = 0 ;
35879 int res2 = 0 ;
35880 PyObject * obj0 = 0 ;
35881 PyObject * obj1 = 0 ;
35882 char * kwnames[] = {
35883 (char *) "self",(char *) "font", NULL
35884 };
35885
35886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35888 if (!SWIG_IsOK(res1)) {
35889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35890 }
35891 arg1 = reinterpret_cast< wxWindow * >(argp1);
35892 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35893 if (!SWIG_IsOK(res2)) {
35894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35895 }
35896 if (!argp2) {
35897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35898 }
35899 arg2 = reinterpret_cast< wxFont * >(argp2);
35900 {
35901 PyThreadState* __tstate = wxPyBeginAllowThreads();
35902 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35903 wxPyEndAllowThreads(__tstate);
35904 if (PyErr_Occurred()) SWIG_fail;
35905 }
35906 {
35907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35908 }
35909 return resultobj;
35910 fail:
35911 return NULL;
35912 }
35913
35914
35915 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35916 PyObject *resultobj = 0;
35917 wxWindow *arg1 = (wxWindow *) 0 ;
35918 wxFont *arg2 = 0 ;
35919 void *argp1 = 0 ;
35920 int res1 = 0 ;
35921 void *argp2 = 0 ;
35922 int res2 = 0 ;
35923 PyObject * obj0 = 0 ;
35924 PyObject * obj1 = 0 ;
35925 char * kwnames[] = {
35926 (char *) "self",(char *) "font", NULL
35927 };
35928
35929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35931 if (!SWIG_IsOK(res1)) {
35932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35933 }
35934 arg1 = reinterpret_cast< wxWindow * >(argp1);
35935 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35936 if (!SWIG_IsOK(res2)) {
35937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35938 }
35939 if (!argp2) {
35940 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35941 }
35942 arg2 = reinterpret_cast< wxFont * >(argp2);
35943 {
35944 PyThreadState* __tstate = wxPyBeginAllowThreads();
35945 (arg1)->SetOwnFont((wxFont const &)*arg2);
35946 wxPyEndAllowThreads(__tstate);
35947 if (PyErr_Occurred()) SWIG_fail;
35948 }
35949 resultobj = SWIG_Py_Void();
35950 return resultobj;
35951 fail:
35952 return NULL;
35953 }
35954
35955
35956 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35957 PyObject *resultobj = 0;
35958 wxWindow *arg1 = (wxWindow *) 0 ;
35959 wxFont result;
35960 void *argp1 = 0 ;
35961 int res1 = 0 ;
35962 PyObject *swig_obj[1] ;
35963
35964 if (!args) SWIG_fail;
35965 swig_obj[0] = args;
35966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35967 if (!SWIG_IsOK(res1)) {
35968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35969 }
35970 arg1 = reinterpret_cast< wxWindow * >(argp1);
35971 {
35972 PyThreadState* __tstate = wxPyBeginAllowThreads();
35973 result = (arg1)->GetFont();
35974 wxPyEndAllowThreads(__tstate);
35975 if (PyErr_Occurred()) SWIG_fail;
35976 }
35977 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35978 return resultobj;
35979 fail:
35980 return NULL;
35981 }
35982
35983
35984 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35985 PyObject *resultobj = 0;
35986 wxWindow *arg1 = (wxWindow *) 0 ;
35987 wxCaret *arg2 = (wxCaret *) 0 ;
35988 void *argp1 = 0 ;
35989 int res1 = 0 ;
35990 int res2 = 0 ;
35991 PyObject * obj0 = 0 ;
35992 PyObject * obj1 = 0 ;
35993 char * kwnames[] = {
35994 (char *) "self",(char *) "caret", NULL
35995 };
35996
35997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35999 if (!SWIG_IsOK(res1)) {
36000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36001 }
36002 arg1 = reinterpret_cast< wxWindow * >(argp1);
36003 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36004 if (!SWIG_IsOK(res2)) {
36005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36006 }
36007 {
36008 PyThreadState* __tstate = wxPyBeginAllowThreads();
36009 (arg1)->SetCaret(arg2);
36010 wxPyEndAllowThreads(__tstate);
36011 if (PyErr_Occurred()) SWIG_fail;
36012 }
36013 resultobj = SWIG_Py_Void();
36014 return resultobj;
36015 fail:
36016 return NULL;
36017 }
36018
36019
36020 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36021 PyObject *resultobj = 0;
36022 wxWindow *arg1 = (wxWindow *) 0 ;
36023 wxCaret *result = 0 ;
36024 void *argp1 = 0 ;
36025 int res1 = 0 ;
36026 PyObject *swig_obj[1] ;
36027
36028 if (!args) SWIG_fail;
36029 swig_obj[0] = args;
36030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36031 if (!SWIG_IsOK(res1)) {
36032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36033 }
36034 arg1 = reinterpret_cast< wxWindow * >(argp1);
36035 {
36036 PyThreadState* __tstate = wxPyBeginAllowThreads();
36037 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36038 wxPyEndAllowThreads(__tstate);
36039 if (PyErr_Occurred()) SWIG_fail;
36040 }
36041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36042 return resultobj;
36043 fail:
36044 return NULL;
36045 }
36046
36047
36048 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36049 PyObject *resultobj = 0;
36050 wxWindow *arg1 = (wxWindow *) 0 ;
36051 int result;
36052 void *argp1 = 0 ;
36053 int res1 = 0 ;
36054 PyObject *swig_obj[1] ;
36055
36056 if (!args) SWIG_fail;
36057 swig_obj[0] = args;
36058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36059 if (!SWIG_IsOK(res1)) {
36060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36061 }
36062 arg1 = reinterpret_cast< wxWindow * >(argp1);
36063 {
36064 PyThreadState* __tstate = wxPyBeginAllowThreads();
36065 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36066 wxPyEndAllowThreads(__tstate);
36067 if (PyErr_Occurred()) SWIG_fail;
36068 }
36069 resultobj = SWIG_From_int(static_cast< int >(result));
36070 return resultobj;
36071 fail:
36072 return NULL;
36073 }
36074
36075
36076 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36077 PyObject *resultobj = 0;
36078 wxWindow *arg1 = (wxWindow *) 0 ;
36079 int result;
36080 void *argp1 = 0 ;
36081 int res1 = 0 ;
36082 PyObject *swig_obj[1] ;
36083
36084 if (!args) SWIG_fail;
36085 swig_obj[0] = args;
36086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36087 if (!SWIG_IsOK(res1)) {
36088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36089 }
36090 arg1 = reinterpret_cast< wxWindow * >(argp1);
36091 {
36092 PyThreadState* __tstate = wxPyBeginAllowThreads();
36093 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36094 wxPyEndAllowThreads(__tstate);
36095 if (PyErr_Occurred()) SWIG_fail;
36096 }
36097 resultobj = SWIG_From_int(static_cast< int >(result));
36098 return resultobj;
36099 fail:
36100 return NULL;
36101 }
36102
36103
36104 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36105 PyObject *resultobj = 0;
36106 wxWindow *arg1 = (wxWindow *) 0 ;
36107 wxString *arg2 = 0 ;
36108 int *arg3 = (int *) 0 ;
36109 int *arg4 = (int *) 0 ;
36110 void *argp1 = 0 ;
36111 int res1 = 0 ;
36112 bool temp2 = false ;
36113 int temp3 ;
36114 int res3 = SWIG_TMPOBJ ;
36115 int temp4 ;
36116 int res4 = SWIG_TMPOBJ ;
36117 PyObject * obj0 = 0 ;
36118 PyObject * obj1 = 0 ;
36119 char * kwnames[] = {
36120 (char *) "self",(char *) "string", NULL
36121 };
36122
36123 arg3 = &temp3;
36124 arg4 = &temp4;
36125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36127 if (!SWIG_IsOK(res1)) {
36128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36129 }
36130 arg1 = reinterpret_cast< wxWindow * >(argp1);
36131 {
36132 arg2 = wxString_in_helper(obj1);
36133 if (arg2 == NULL) SWIG_fail;
36134 temp2 = true;
36135 }
36136 {
36137 PyThreadState* __tstate = wxPyBeginAllowThreads();
36138 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36139 wxPyEndAllowThreads(__tstate);
36140 if (PyErr_Occurred()) SWIG_fail;
36141 }
36142 resultobj = SWIG_Py_Void();
36143 if (SWIG_IsTmpObj(res3)) {
36144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36145 } else {
36146 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36148 }
36149 if (SWIG_IsTmpObj(res4)) {
36150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36151 } else {
36152 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36154 }
36155 {
36156 if (temp2)
36157 delete arg2;
36158 }
36159 return resultobj;
36160 fail:
36161 {
36162 if (temp2)
36163 delete arg2;
36164 }
36165 return NULL;
36166 }
36167
36168
36169 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36170 PyObject *resultobj = 0;
36171 wxWindow *arg1 = (wxWindow *) 0 ;
36172 wxString *arg2 = 0 ;
36173 int *arg3 = (int *) 0 ;
36174 int *arg4 = (int *) 0 ;
36175 int *arg5 = (int *) 0 ;
36176 int *arg6 = (int *) 0 ;
36177 wxFont *arg7 = (wxFont *) NULL ;
36178 void *argp1 = 0 ;
36179 int res1 = 0 ;
36180 bool temp2 = false ;
36181 int temp3 ;
36182 int res3 = SWIG_TMPOBJ ;
36183 int temp4 ;
36184 int res4 = SWIG_TMPOBJ ;
36185 int temp5 ;
36186 int res5 = SWIG_TMPOBJ ;
36187 int temp6 ;
36188 int res6 = SWIG_TMPOBJ ;
36189 void *argp7 = 0 ;
36190 int res7 = 0 ;
36191 PyObject * obj0 = 0 ;
36192 PyObject * obj1 = 0 ;
36193 PyObject * obj2 = 0 ;
36194 char * kwnames[] = {
36195 (char *) "self",(char *) "string",(char *) "font", NULL
36196 };
36197
36198 arg3 = &temp3;
36199 arg4 = &temp4;
36200 arg5 = &temp5;
36201 arg6 = &temp6;
36202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36204 if (!SWIG_IsOK(res1)) {
36205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36206 }
36207 arg1 = reinterpret_cast< wxWindow * >(argp1);
36208 {
36209 arg2 = wxString_in_helper(obj1);
36210 if (arg2 == NULL) SWIG_fail;
36211 temp2 = true;
36212 }
36213 if (obj2) {
36214 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36215 if (!SWIG_IsOK(res7)) {
36216 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36217 }
36218 arg7 = reinterpret_cast< wxFont * >(argp7);
36219 }
36220 {
36221 PyThreadState* __tstate = wxPyBeginAllowThreads();
36222 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36223 wxPyEndAllowThreads(__tstate);
36224 if (PyErr_Occurred()) SWIG_fail;
36225 }
36226 resultobj = SWIG_Py_Void();
36227 if (SWIG_IsTmpObj(res3)) {
36228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36229 } else {
36230 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36232 }
36233 if (SWIG_IsTmpObj(res4)) {
36234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36235 } else {
36236 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36238 }
36239 if (SWIG_IsTmpObj(res5)) {
36240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36241 } else {
36242 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36244 }
36245 if (SWIG_IsTmpObj(res6)) {
36246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36247 } else {
36248 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36250 }
36251 {
36252 if (temp2)
36253 delete arg2;
36254 }
36255 return resultobj;
36256 fail:
36257 {
36258 if (temp2)
36259 delete arg2;
36260 }
36261 return NULL;
36262 }
36263
36264
36265 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36266 PyObject *resultobj = 0;
36267 wxWindow *arg1 = (wxWindow *) 0 ;
36268 int *arg2 = (int *) 0 ;
36269 int *arg3 = (int *) 0 ;
36270 void *argp1 = 0 ;
36271 int res1 = 0 ;
36272 int temp2 ;
36273 int res2 = 0 ;
36274 int temp3 ;
36275 int res3 = 0 ;
36276 PyObject * obj0 = 0 ;
36277 PyObject * obj1 = 0 ;
36278 PyObject * obj2 = 0 ;
36279 char * kwnames[] = {
36280 (char *) "self",(char *) "x",(char *) "y", NULL
36281 };
36282
36283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36285 if (!SWIG_IsOK(res1)) {
36286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36287 }
36288 arg1 = reinterpret_cast< wxWindow * >(argp1);
36289 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36290 int val;
36291 int ecode = SWIG_AsVal_int(obj1, &val);
36292 if (!SWIG_IsOK(ecode)) {
36293 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36294 }
36295 temp2 = static_cast< int >(val);
36296 arg2 = &temp2;
36297 res2 = SWIG_AddTmpMask(ecode);
36298 }
36299 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36300 int val;
36301 int ecode = SWIG_AsVal_int(obj2, &val);
36302 if (!SWIG_IsOK(ecode)) {
36303 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36304 }
36305 temp3 = static_cast< int >(val);
36306 arg3 = &temp3;
36307 res3 = SWIG_AddTmpMask(ecode);
36308 }
36309 {
36310 PyThreadState* __tstate = wxPyBeginAllowThreads();
36311 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36312 wxPyEndAllowThreads(__tstate);
36313 if (PyErr_Occurred()) SWIG_fail;
36314 }
36315 resultobj = SWIG_Py_Void();
36316 if (SWIG_IsTmpObj(res2)) {
36317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36318 } else {
36319 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36321 }
36322 if (SWIG_IsTmpObj(res3)) {
36323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36324 } else {
36325 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36327 }
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36335 PyObject *resultobj = 0;
36336 wxWindow *arg1 = (wxWindow *) 0 ;
36337 int *arg2 = (int *) 0 ;
36338 int *arg3 = (int *) 0 ;
36339 void *argp1 = 0 ;
36340 int res1 = 0 ;
36341 int temp2 ;
36342 int res2 = 0 ;
36343 int temp3 ;
36344 int res3 = 0 ;
36345 PyObject * obj0 = 0 ;
36346 PyObject * obj1 = 0 ;
36347 PyObject * obj2 = 0 ;
36348 char * kwnames[] = {
36349 (char *) "self",(char *) "x",(char *) "y", NULL
36350 };
36351
36352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36354 if (!SWIG_IsOK(res1)) {
36355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36356 }
36357 arg1 = reinterpret_cast< wxWindow * >(argp1);
36358 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36359 int val;
36360 int ecode = SWIG_AsVal_int(obj1, &val);
36361 if (!SWIG_IsOK(ecode)) {
36362 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36363 }
36364 temp2 = static_cast< int >(val);
36365 arg2 = &temp2;
36366 res2 = SWIG_AddTmpMask(ecode);
36367 }
36368 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36369 int val;
36370 int ecode = SWIG_AsVal_int(obj2, &val);
36371 if (!SWIG_IsOK(ecode)) {
36372 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36373 }
36374 temp3 = static_cast< int >(val);
36375 arg3 = &temp3;
36376 res3 = SWIG_AddTmpMask(ecode);
36377 }
36378 {
36379 PyThreadState* __tstate = wxPyBeginAllowThreads();
36380 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36381 wxPyEndAllowThreads(__tstate);
36382 if (PyErr_Occurred()) SWIG_fail;
36383 }
36384 resultobj = SWIG_Py_Void();
36385 if (SWIG_IsTmpObj(res2)) {
36386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36387 } else {
36388 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36390 }
36391 if (SWIG_IsTmpObj(res3)) {
36392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36393 } else {
36394 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36396 }
36397 return resultobj;
36398 fail:
36399 return NULL;
36400 }
36401
36402
36403 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36404 PyObject *resultobj = 0;
36405 wxWindow *arg1 = (wxWindow *) 0 ;
36406 wxPoint *arg2 = 0 ;
36407 wxPoint result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 wxPoint temp2 ;
36411 PyObject * obj0 = 0 ;
36412 PyObject * obj1 = 0 ;
36413 char * kwnames[] = {
36414 (char *) "self",(char *) "pt", NULL
36415 };
36416
36417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36419 if (!SWIG_IsOK(res1)) {
36420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36421 }
36422 arg1 = reinterpret_cast< wxWindow * >(argp1);
36423 {
36424 arg2 = &temp2;
36425 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36426 }
36427 {
36428 PyThreadState* __tstate = wxPyBeginAllowThreads();
36429 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36430 wxPyEndAllowThreads(__tstate);
36431 if (PyErr_Occurred()) SWIG_fail;
36432 }
36433 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36434 return resultobj;
36435 fail:
36436 return NULL;
36437 }
36438
36439
36440 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36441 PyObject *resultobj = 0;
36442 wxWindow *arg1 = (wxWindow *) 0 ;
36443 wxPoint *arg2 = 0 ;
36444 wxPoint result;
36445 void *argp1 = 0 ;
36446 int res1 = 0 ;
36447 wxPoint temp2 ;
36448 PyObject * obj0 = 0 ;
36449 PyObject * obj1 = 0 ;
36450 char * kwnames[] = {
36451 (char *) "self",(char *) "pt", NULL
36452 };
36453
36454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36456 if (!SWIG_IsOK(res1)) {
36457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36458 }
36459 arg1 = reinterpret_cast< wxWindow * >(argp1);
36460 {
36461 arg2 = &temp2;
36462 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36463 }
36464 {
36465 PyThreadState* __tstate = wxPyBeginAllowThreads();
36466 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36467 wxPyEndAllowThreads(__tstate);
36468 if (PyErr_Occurred()) SWIG_fail;
36469 }
36470 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36471 return resultobj;
36472 fail:
36473 return NULL;
36474 }
36475
36476
36477 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36478 PyObject *resultobj = 0;
36479 wxWindow *arg1 = (wxWindow *) 0 ;
36480 int arg2 ;
36481 int arg3 ;
36482 wxHitTest result;
36483 void *argp1 = 0 ;
36484 int res1 = 0 ;
36485 int val2 ;
36486 int ecode2 = 0 ;
36487 int val3 ;
36488 int ecode3 = 0 ;
36489 PyObject * obj0 = 0 ;
36490 PyObject * obj1 = 0 ;
36491 PyObject * obj2 = 0 ;
36492 char * kwnames[] = {
36493 (char *) "self",(char *) "x",(char *) "y", NULL
36494 };
36495
36496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36498 if (!SWIG_IsOK(res1)) {
36499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36500 }
36501 arg1 = reinterpret_cast< wxWindow * >(argp1);
36502 ecode2 = SWIG_AsVal_int(obj1, &val2);
36503 if (!SWIG_IsOK(ecode2)) {
36504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36505 }
36506 arg2 = static_cast< int >(val2);
36507 ecode3 = SWIG_AsVal_int(obj2, &val3);
36508 if (!SWIG_IsOK(ecode3)) {
36509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36510 }
36511 arg3 = static_cast< int >(val3);
36512 {
36513 PyThreadState* __tstate = wxPyBeginAllowThreads();
36514 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36515 wxPyEndAllowThreads(__tstate);
36516 if (PyErr_Occurred()) SWIG_fail;
36517 }
36518 resultobj = SWIG_From_int(static_cast< int >(result));
36519 return resultobj;
36520 fail:
36521 return NULL;
36522 }
36523
36524
36525 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36526 PyObject *resultobj = 0;
36527 wxWindow *arg1 = (wxWindow *) 0 ;
36528 wxPoint *arg2 = 0 ;
36529 wxHitTest result;
36530 void *argp1 = 0 ;
36531 int res1 = 0 ;
36532 wxPoint temp2 ;
36533 PyObject * obj0 = 0 ;
36534 PyObject * obj1 = 0 ;
36535 char * kwnames[] = {
36536 (char *) "self",(char *) "pt", NULL
36537 };
36538
36539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36541 if (!SWIG_IsOK(res1)) {
36542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36543 }
36544 arg1 = reinterpret_cast< wxWindow * >(argp1);
36545 {
36546 arg2 = &temp2;
36547 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36548 }
36549 {
36550 PyThreadState* __tstate = wxPyBeginAllowThreads();
36551 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36552 wxPyEndAllowThreads(__tstate);
36553 if (PyErr_Occurred()) SWIG_fail;
36554 }
36555 resultobj = SWIG_From_int(static_cast< int >(result));
36556 return resultobj;
36557 fail:
36558 return NULL;
36559 }
36560
36561
36562 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36563 PyObject *resultobj = 0;
36564 wxWindow *arg1 = (wxWindow *) 0 ;
36565 long arg2 ;
36566 wxBorder result;
36567 void *argp1 = 0 ;
36568 int res1 = 0 ;
36569 long val2 ;
36570 int ecode2 = 0 ;
36571
36572 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36574 if (!SWIG_IsOK(res1)) {
36575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36576 }
36577 arg1 = reinterpret_cast< wxWindow * >(argp1);
36578 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36579 if (!SWIG_IsOK(ecode2)) {
36580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36581 }
36582 arg2 = static_cast< long >(val2);
36583 {
36584 PyThreadState* __tstate = wxPyBeginAllowThreads();
36585 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36586 wxPyEndAllowThreads(__tstate);
36587 if (PyErr_Occurred()) SWIG_fail;
36588 }
36589 resultobj = SWIG_From_int(static_cast< int >(result));
36590 return resultobj;
36591 fail:
36592 return NULL;
36593 }
36594
36595
36596 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36597 PyObject *resultobj = 0;
36598 wxWindow *arg1 = (wxWindow *) 0 ;
36599 wxBorder result;
36600 void *argp1 = 0 ;
36601 int res1 = 0 ;
36602
36603 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36605 if (!SWIG_IsOK(res1)) {
36606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36607 }
36608 arg1 = reinterpret_cast< wxWindow * >(argp1);
36609 {
36610 PyThreadState* __tstate = wxPyBeginAllowThreads();
36611 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36612 wxPyEndAllowThreads(__tstate);
36613 if (PyErr_Occurred()) SWIG_fail;
36614 }
36615 resultobj = SWIG_From_int(static_cast< int >(result));
36616 return resultobj;
36617 fail:
36618 return NULL;
36619 }
36620
36621
36622 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36623 int argc;
36624 PyObject *argv[3];
36625
36626 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36627 --argc;
36628 if (argc == 1) {
36629 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36630 }
36631 if (argc == 2) {
36632 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36633 }
36634
36635 fail:
36636 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36637 return NULL;
36638 }
36639
36640
36641 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36642 PyObject *resultobj = 0;
36643 wxWindow *arg1 = (wxWindow *) 0 ;
36644 long arg2 = (long) wxUPDATE_UI_NONE ;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 long val2 ;
36648 int ecode2 = 0 ;
36649 PyObject * obj0 = 0 ;
36650 PyObject * obj1 = 0 ;
36651 char * kwnames[] = {
36652 (char *) "self",(char *) "flags", NULL
36653 };
36654
36655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36657 if (!SWIG_IsOK(res1)) {
36658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36659 }
36660 arg1 = reinterpret_cast< wxWindow * >(argp1);
36661 if (obj1) {
36662 ecode2 = SWIG_AsVal_long(obj1, &val2);
36663 if (!SWIG_IsOK(ecode2)) {
36664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36665 }
36666 arg2 = static_cast< long >(val2);
36667 }
36668 {
36669 PyThreadState* __tstate = wxPyBeginAllowThreads();
36670 (arg1)->UpdateWindowUI(arg2);
36671 wxPyEndAllowThreads(__tstate);
36672 if (PyErr_Occurred()) SWIG_fail;
36673 }
36674 resultobj = SWIG_Py_Void();
36675 return resultobj;
36676 fail:
36677 return NULL;
36678 }
36679
36680
36681 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36682 PyObject *resultobj = 0;
36683 wxWindow *arg1 = (wxWindow *) 0 ;
36684 wxMenu *arg2 = (wxMenu *) 0 ;
36685 int arg3 = (int) -1 ;
36686 int arg4 = (int) -1 ;
36687 bool result;
36688 void *argp1 = 0 ;
36689 int res1 = 0 ;
36690 void *argp2 = 0 ;
36691 int res2 = 0 ;
36692 int val3 ;
36693 int ecode3 = 0 ;
36694 int val4 ;
36695 int ecode4 = 0 ;
36696 PyObject * obj0 = 0 ;
36697 PyObject * obj1 = 0 ;
36698 PyObject * obj2 = 0 ;
36699 PyObject * obj3 = 0 ;
36700 char * kwnames[] = {
36701 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36702 };
36703
36704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36706 if (!SWIG_IsOK(res1)) {
36707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36708 }
36709 arg1 = reinterpret_cast< wxWindow * >(argp1);
36710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36711 if (!SWIG_IsOK(res2)) {
36712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36713 }
36714 arg2 = reinterpret_cast< wxMenu * >(argp2);
36715 if (obj2) {
36716 ecode3 = SWIG_AsVal_int(obj2, &val3);
36717 if (!SWIG_IsOK(ecode3)) {
36718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36719 }
36720 arg3 = static_cast< int >(val3);
36721 }
36722 if (obj3) {
36723 ecode4 = SWIG_AsVal_int(obj3, &val4);
36724 if (!SWIG_IsOK(ecode4)) {
36725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36726 }
36727 arg4 = static_cast< int >(val4);
36728 }
36729 {
36730 PyThreadState* __tstate = wxPyBeginAllowThreads();
36731 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36732 wxPyEndAllowThreads(__tstate);
36733 if (PyErr_Occurred()) SWIG_fail;
36734 }
36735 {
36736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36737 }
36738 return resultobj;
36739 fail:
36740 return NULL;
36741 }
36742
36743
36744 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36745 PyObject *resultobj = 0;
36746 wxWindow *arg1 = (wxWindow *) 0 ;
36747 wxMenu *arg2 = (wxMenu *) 0 ;
36748 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36749 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36750 bool result;
36751 void *argp1 = 0 ;
36752 int res1 = 0 ;
36753 void *argp2 = 0 ;
36754 int res2 = 0 ;
36755 wxPoint temp3 ;
36756 PyObject * obj0 = 0 ;
36757 PyObject * obj1 = 0 ;
36758 PyObject * obj2 = 0 ;
36759 char * kwnames[] = {
36760 (char *) "self",(char *) "menu",(char *) "pos", NULL
36761 };
36762
36763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36765 if (!SWIG_IsOK(res1)) {
36766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36767 }
36768 arg1 = reinterpret_cast< wxWindow * >(argp1);
36769 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36770 if (!SWIG_IsOK(res2)) {
36771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36772 }
36773 arg2 = reinterpret_cast< wxMenu * >(argp2);
36774 if (obj2) {
36775 {
36776 arg3 = &temp3;
36777 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36778 }
36779 }
36780 {
36781 PyThreadState* __tstate = wxPyBeginAllowThreads();
36782 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36783 wxPyEndAllowThreads(__tstate);
36784 if (PyErr_Occurred()) SWIG_fail;
36785 }
36786 {
36787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36788 }
36789 return resultobj;
36790 fail:
36791 return NULL;
36792 }
36793
36794
36795 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36796 PyObject *resultobj = 0;
36797 wxWindow *arg1 = (wxWindow *) 0 ;
36798 bool result;
36799 void *argp1 = 0 ;
36800 int res1 = 0 ;
36801 PyObject *swig_obj[1] ;
36802
36803 if (!args) SWIG_fail;
36804 swig_obj[0] = args;
36805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36806 if (!SWIG_IsOK(res1)) {
36807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36808 }
36809 arg1 = reinterpret_cast< wxWindow * >(argp1);
36810 {
36811 PyThreadState* __tstate = wxPyBeginAllowThreads();
36812 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36813 wxPyEndAllowThreads(__tstate);
36814 if (PyErr_Occurred()) SWIG_fail;
36815 }
36816 {
36817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36818 }
36819 return resultobj;
36820 fail:
36821 return NULL;
36822 }
36823
36824
36825 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36826 PyObject *resultobj = 0;
36827 wxWindow *arg1 = (wxWindow *) 0 ;
36828 long result;
36829 void *argp1 = 0 ;
36830 int res1 = 0 ;
36831 PyObject *swig_obj[1] ;
36832
36833 if (!args) SWIG_fail;
36834 swig_obj[0] = args;
36835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36836 if (!SWIG_IsOK(res1)) {
36837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36838 }
36839 arg1 = reinterpret_cast< wxWindow * >(argp1);
36840 {
36841 PyThreadState* __tstate = wxPyBeginAllowThreads();
36842 result = (long)wxWindow_GetHandle(arg1);
36843 wxPyEndAllowThreads(__tstate);
36844 if (PyErr_Occurred()) SWIG_fail;
36845 }
36846 resultobj = SWIG_From_long(static_cast< long >(result));
36847 return resultobj;
36848 fail:
36849 return NULL;
36850 }
36851
36852
36853 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36854 PyObject *resultobj = 0;
36855 wxWindow *arg1 = (wxWindow *) 0 ;
36856 long arg2 ;
36857 void *argp1 = 0 ;
36858 int res1 = 0 ;
36859 long val2 ;
36860 int ecode2 = 0 ;
36861 PyObject * obj0 = 0 ;
36862 PyObject * obj1 = 0 ;
36863 char * kwnames[] = {
36864 (char *) "self",(char *) "handle", NULL
36865 };
36866
36867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36869 if (!SWIG_IsOK(res1)) {
36870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36871 }
36872 arg1 = reinterpret_cast< wxWindow * >(argp1);
36873 ecode2 = SWIG_AsVal_long(obj1, &val2);
36874 if (!SWIG_IsOK(ecode2)) {
36875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36876 }
36877 arg2 = static_cast< long >(val2);
36878 {
36879 PyThreadState* __tstate = wxPyBeginAllowThreads();
36880 wxWindow_AssociateHandle(arg1,arg2);
36881 wxPyEndAllowThreads(__tstate);
36882 if (PyErr_Occurred()) SWIG_fail;
36883 }
36884 resultobj = SWIG_Py_Void();
36885 return resultobj;
36886 fail:
36887 return NULL;
36888 }
36889
36890
36891 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36892 PyObject *resultobj = 0;
36893 wxWindow *arg1 = (wxWindow *) 0 ;
36894 void *argp1 = 0 ;
36895 int res1 = 0 ;
36896 PyObject *swig_obj[1] ;
36897
36898 if (!args) SWIG_fail;
36899 swig_obj[0] = args;
36900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36903 }
36904 arg1 = reinterpret_cast< wxWindow * >(argp1);
36905 {
36906 PyThreadState* __tstate = wxPyBeginAllowThreads();
36907 (arg1)->DissociateHandle();
36908 wxPyEndAllowThreads(__tstate);
36909 if (PyErr_Occurred()) SWIG_fail;
36910 }
36911 resultobj = SWIG_Py_Void();
36912 return resultobj;
36913 fail:
36914 return NULL;
36915 }
36916
36917
36918 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36919 PyObject *resultobj = 0;
36920 wxWindow *arg1 = (wxWindow *) 0 ;
36921 int arg2 ;
36922 bool result;
36923 void *argp1 = 0 ;
36924 int res1 = 0 ;
36925 int val2 ;
36926 int ecode2 = 0 ;
36927 PyObject * obj0 = 0 ;
36928 PyObject * obj1 = 0 ;
36929 char * kwnames[] = {
36930 (char *) "self",(char *) "orient", NULL
36931 };
36932
36933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36935 if (!SWIG_IsOK(res1)) {
36936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36937 }
36938 arg1 = reinterpret_cast< wxWindow * >(argp1);
36939 ecode2 = SWIG_AsVal_int(obj1, &val2);
36940 if (!SWIG_IsOK(ecode2)) {
36941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36942 }
36943 arg2 = static_cast< int >(val2);
36944 {
36945 PyThreadState* __tstate = wxPyBeginAllowThreads();
36946 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36947 wxPyEndAllowThreads(__tstate);
36948 if (PyErr_Occurred()) SWIG_fail;
36949 }
36950 {
36951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36952 }
36953 return resultobj;
36954 fail:
36955 return NULL;
36956 }
36957
36958
36959 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36960 PyObject *resultobj = 0;
36961 wxWindow *arg1 = (wxWindow *) 0 ;
36962 int arg2 ;
36963 int arg3 ;
36964 int arg4 ;
36965 int arg5 ;
36966 bool arg6 = (bool) true ;
36967 void *argp1 = 0 ;
36968 int res1 = 0 ;
36969 int val2 ;
36970 int ecode2 = 0 ;
36971 int val3 ;
36972 int ecode3 = 0 ;
36973 int val4 ;
36974 int ecode4 = 0 ;
36975 int val5 ;
36976 int ecode5 = 0 ;
36977 bool val6 ;
36978 int ecode6 = 0 ;
36979 PyObject * obj0 = 0 ;
36980 PyObject * obj1 = 0 ;
36981 PyObject * obj2 = 0 ;
36982 PyObject * obj3 = 0 ;
36983 PyObject * obj4 = 0 ;
36984 PyObject * obj5 = 0 ;
36985 char * kwnames[] = {
36986 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36987 };
36988
36989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36991 if (!SWIG_IsOK(res1)) {
36992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36993 }
36994 arg1 = reinterpret_cast< wxWindow * >(argp1);
36995 ecode2 = SWIG_AsVal_int(obj1, &val2);
36996 if (!SWIG_IsOK(ecode2)) {
36997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36998 }
36999 arg2 = static_cast< int >(val2);
37000 ecode3 = SWIG_AsVal_int(obj2, &val3);
37001 if (!SWIG_IsOK(ecode3)) {
37002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37003 }
37004 arg3 = static_cast< int >(val3);
37005 ecode4 = SWIG_AsVal_int(obj3, &val4);
37006 if (!SWIG_IsOK(ecode4)) {
37007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37008 }
37009 arg4 = static_cast< int >(val4);
37010 ecode5 = SWIG_AsVal_int(obj4, &val5);
37011 if (!SWIG_IsOK(ecode5)) {
37012 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37013 }
37014 arg5 = static_cast< int >(val5);
37015 if (obj5) {
37016 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37017 if (!SWIG_IsOK(ecode6)) {
37018 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37019 }
37020 arg6 = static_cast< bool >(val6);
37021 }
37022 {
37023 PyThreadState* __tstate = wxPyBeginAllowThreads();
37024 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37025 wxPyEndAllowThreads(__tstate);
37026 if (PyErr_Occurred()) SWIG_fail;
37027 }
37028 resultobj = SWIG_Py_Void();
37029 return resultobj;
37030 fail:
37031 return NULL;
37032 }
37033
37034
37035 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37036 PyObject *resultobj = 0;
37037 wxWindow *arg1 = (wxWindow *) 0 ;
37038 int arg2 ;
37039 int arg3 ;
37040 bool arg4 = (bool) true ;
37041 void *argp1 = 0 ;
37042 int res1 = 0 ;
37043 int val2 ;
37044 int ecode2 = 0 ;
37045 int val3 ;
37046 int ecode3 = 0 ;
37047 bool val4 ;
37048 int ecode4 = 0 ;
37049 PyObject * obj0 = 0 ;
37050 PyObject * obj1 = 0 ;
37051 PyObject * obj2 = 0 ;
37052 PyObject * obj3 = 0 ;
37053 char * kwnames[] = {
37054 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37055 };
37056
37057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37059 if (!SWIG_IsOK(res1)) {
37060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37061 }
37062 arg1 = reinterpret_cast< wxWindow * >(argp1);
37063 ecode2 = SWIG_AsVal_int(obj1, &val2);
37064 if (!SWIG_IsOK(ecode2)) {
37065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37066 }
37067 arg2 = static_cast< int >(val2);
37068 ecode3 = SWIG_AsVal_int(obj2, &val3);
37069 if (!SWIG_IsOK(ecode3)) {
37070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37071 }
37072 arg3 = static_cast< int >(val3);
37073 if (obj3) {
37074 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37075 if (!SWIG_IsOK(ecode4)) {
37076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37077 }
37078 arg4 = static_cast< bool >(val4);
37079 }
37080 {
37081 PyThreadState* __tstate = wxPyBeginAllowThreads();
37082 (arg1)->SetScrollPos(arg2,arg3,arg4);
37083 wxPyEndAllowThreads(__tstate);
37084 if (PyErr_Occurred()) SWIG_fail;
37085 }
37086 resultobj = SWIG_Py_Void();
37087 return resultobj;
37088 fail:
37089 return NULL;
37090 }
37091
37092
37093 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37094 PyObject *resultobj = 0;
37095 wxWindow *arg1 = (wxWindow *) 0 ;
37096 int arg2 ;
37097 int result;
37098 void *argp1 = 0 ;
37099 int res1 = 0 ;
37100 int val2 ;
37101 int ecode2 = 0 ;
37102 PyObject * obj0 = 0 ;
37103 PyObject * obj1 = 0 ;
37104 char * kwnames[] = {
37105 (char *) "self",(char *) "orientation", NULL
37106 };
37107
37108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37110 if (!SWIG_IsOK(res1)) {
37111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37112 }
37113 arg1 = reinterpret_cast< wxWindow * >(argp1);
37114 ecode2 = SWIG_AsVal_int(obj1, &val2);
37115 if (!SWIG_IsOK(ecode2)) {
37116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37117 }
37118 arg2 = static_cast< int >(val2);
37119 {
37120 PyThreadState* __tstate = wxPyBeginAllowThreads();
37121 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37122 wxPyEndAllowThreads(__tstate);
37123 if (PyErr_Occurred()) SWIG_fail;
37124 }
37125 resultobj = SWIG_From_int(static_cast< int >(result));
37126 return resultobj;
37127 fail:
37128 return NULL;
37129 }
37130
37131
37132 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37133 PyObject *resultobj = 0;
37134 wxWindow *arg1 = (wxWindow *) 0 ;
37135 int arg2 ;
37136 int result;
37137 void *argp1 = 0 ;
37138 int res1 = 0 ;
37139 int val2 ;
37140 int ecode2 = 0 ;
37141 PyObject * obj0 = 0 ;
37142 PyObject * obj1 = 0 ;
37143 char * kwnames[] = {
37144 (char *) "self",(char *) "orientation", NULL
37145 };
37146
37147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37149 if (!SWIG_IsOK(res1)) {
37150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37151 }
37152 arg1 = reinterpret_cast< wxWindow * >(argp1);
37153 ecode2 = SWIG_AsVal_int(obj1, &val2);
37154 if (!SWIG_IsOK(ecode2)) {
37155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37156 }
37157 arg2 = static_cast< int >(val2);
37158 {
37159 PyThreadState* __tstate = wxPyBeginAllowThreads();
37160 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 resultobj = SWIG_From_int(static_cast< int >(result));
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37172 PyObject *resultobj = 0;
37173 wxWindow *arg1 = (wxWindow *) 0 ;
37174 int arg2 ;
37175 int result;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 int val2 ;
37179 int ecode2 = 0 ;
37180 PyObject * obj0 = 0 ;
37181 PyObject * obj1 = 0 ;
37182 char * kwnames[] = {
37183 (char *) "self",(char *) "orientation", NULL
37184 };
37185
37186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37188 if (!SWIG_IsOK(res1)) {
37189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37190 }
37191 arg1 = reinterpret_cast< wxWindow * >(argp1);
37192 ecode2 = SWIG_AsVal_int(obj1, &val2);
37193 if (!SWIG_IsOK(ecode2)) {
37194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37195 }
37196 arg2 = static_cast< int >(val2);
37197 {
37198 PyThreadState* __tstate = wxPyBeginAllowThreads();
37199 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37200 wxPyEndAllowThreads(__tstate);
37201 if (PyErr_Occurred()) SWIG_fail;
37202 }
37203 resultobj = SWIG_From_int(static_cast< int >(result));
37204 return resultobj;
37205 fail:
37206 return NULL;
37207 }
37208
37209
37210 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37211 PyObject *resultobj = 0;
37212 wxWindow *arg1 = (wxWindow *) 0 ;
37213 int arg2 ;
37214 int arg3 ;
37215 wxRect *arg4 = (wxRect *) NULL ;
37216 void *argp1 = 0 ;
37217 int res1 = 0 ;
37218 int val2 ;
37219 int ecode2 = 0 ;
37220 int val3 ;
37221 int ecode3 = 0 ;
37222 void *argp4 = 0 ;
37223 int res4 = 0 ;
37224 PyObject * obj0 = 0 ;
37225 PyObject * obj1 = 0 ;
37226 PyObject * obj2 = 0 ;
37227 PyObject * obj3 = 0 ;
37228 char * kwnames[] = {
37229 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37230 };
37231
37232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37234 if (!SWIG_IsOK(res1)) {
37235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37236 }
37237 arg1 = reinterpret_cast< wxWindow * >(argp1);
37238 ecode2 = SWIG_AsVal_int(obj1, &val2);
37239 if (!SWIG_IsOK(ecode2)) {
37240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37241 }
37242 arg2 = static_cast< int >(val2);
37243 ecode3 = SWIG_AsVal_int(obj2, &val3);
37244 if (!SWIG_IsOK(ecode3)) {
37245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37246 }
37247 arg3 = static_cast< int >(val3);
37248 if (obj3) {
37249 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37250 if (!SWIG_IsOK(res4)) {
37251 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37252 }
37253 arg4 = reinterpret_cast< wxRect * >(argp4);
37254 }
37255 {
37256 PyThreadState* __tstate = wxPyBeginAllowThreads();
37257 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37258 wxPyEndAllowThreads(__tstate);
37259 if (PyErr_Occurred()) SWIG_fail;
37260 }
37261 resultobj = SWIG_Py_Void();
37262 return resultobj;
37263 fail:
37264 return NULL;
37265 }
37266
37267
37268 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37269 PyObject *resultobj = 0;
37270 wxWindow *arg1 = (wxWindow *) 0 ;
37271 int arg2 ;
37272 bool result;
37273 void *argp1 = 0 ;
37274 int res1 = 0 ;
37275 int val2 ;
37276 int ecode2 = 0 ;
37277 PyObject * obj0 = 0 ;
37278 PyObject * obj1 = 0 ;
37279 char * kwnames[] = {
37280 (char *) "self",(char *) "lines", NULL
37281 };
37282
37283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37285 if (!SWIG_IsOK(res1)) {
37286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37287 }
37288 arg1 = reinterpret_cast< wxWindow * >(argp1);
37289 ecode2 = SWIG_AsVal_int(obj1, &val2);
37290 if (!SWIG_IsOK(ecode2)) {
37291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37292 }
37293 arg2 = static_cast< int >(val2);
37294 {
37295 PyThreadState* __tstate = wxPyBeginAllowThreads();
37296 result = (bool)(arg1)->ScrollLines(arg2);
37297 wxPyEndAllowThreads(__tstate);
37298 if (PyErr_Occurred()) SWIG_fail;
37299 }
37300 {
37301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37302 }
37303 return resultobj;
37304 fail:
37305 return NULL;
37306 }
37307
37308
37309 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37310 PyObject *resultobj = 0;
37311 wxWindow *arg1 = (wxWindow *) 0 ;
37312 int arg2 ;
37313 bool result;
37314 void *argp1 = 0 ;
37315 int res1 = 0 ;
37316 int val2 ;
37317 int ecode2 = 0 ;
37318 PyObject * obj0 = 0 ;
37319 PyObject * obj1 = 0 ;
37320 char * kwnames[] = {
37321 (char *) "self",(char *) "pages", NULL
37322 };
37323
37324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37326 if (!SWIG_IsOK(res1)) {
37327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37328 }
37329 arg1 = reinterpret_cast< wxWindow * >(argp1);
37330 ecode2 = SWIG_AsVal_int(obj1, &val2);
37331 if (!SWIG_IsOK(ecode2)) {
37332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37333 }
37334 arg2 = static_cast< int >(val2);
37335 {
37336 PyThreadState* __tstate = wxPyBeginAllowThreads();
37337 result = (bool)(arg1)->ScrollPages(arg2);
37338 wxPyEndAllowThreads(__tstate);
37339 if (PyErr_Occurred()) SWIG_fail;
37340 }
37341 {
37342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37343 }
37344 return resultobj;
37345 fail:
37346 return NULL;
37347 }
37348
37349
37350 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37351 PyObject *resultobj = 0;
37352 wxWindow *arg1 = (wxWindow *) 0 ;
37353 bool result;
37354 void *argp1 = 0 ;
37355 int res1 = 0 ;
37356 PyObject *swig_obj[1] ;
37357
37358 if (!args) SWIG_fail;
37359 swig_obj[0] = args;
37360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37361 if (!SWIG_IsOK(res1)) {
37362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37363 }
37364 arg1 = reinterpret_cast< wxWindow * >(argp1);
37365 {
37366 PyThreadState* __tstate = wxPyBeginAllowThreads();
37367 result = (bool)(arg1)->LineUp();
37368 wxPyEndAllowThreads(__tstate);
37369 if (PyErr_Occurred()) SWIG_fail;
37370 }
37371 {
37372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37373 }
37374 return resultobj;
37375 fail:
37376 return NULL;
37377 }
37378
37379
37380 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37381 PyObject *resultobj = 0;
37382 wxWindow *arg1 = (wxWindow *) 0 ;
37383 bool result;
37384 void *argp1 = 0 ;
37385 int res1 = 0 ;
37386 PyObject *swig_obj[1] ;
37387
37388 if (!args) SWIG_fail;
37389 swig_obj[0] = args;
37390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37391 if (!SWIG_IsOK(res1)) {
37392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37393 }
37394 arg1 = reinterpret_cast< wxWindow * >(argp1);
37395 {
37396 PyThreadState* __tstate = wxPyBeginAllowThreads();
37397 result = (bool)(arg1)->LineDown();
37398 wxPyEndAllowThreads(__tstate);
37399 if (PyErr_Occurred()) SWIG_fail;
37400 }
37401 {
37402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37403 }
37404 return resultobj;
37405 fail:
37406 return NULL;
37407 }
37408
37409
37410 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37411 PyObject *resultobj = 0;
37412 wxWindow *arg1 = (wxWindow *) 0 ;
37413 bool result;
37414 void *argp1 = 0 ;
37415 int res1 = 0 ;
37416 PyObject *swig_obj[1] ;
37417
37418 if (!args) SWIG_fail;
37419 swig_obj[0] = args;
37420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37421 if (!SWIG_IsOK(res1)) {
37422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37423 }
37424 arg1 = reinterpret_cast< wxWindow * >(argp1);
37425 {
37426 PyThreadState* __tstate = wxPyBeginAllowThreads();
37427 result = (bool)(arg1)->PageUp();
37428 wxPyEndAllowThreads(__tstate);
37429 if (PyErr_Occurred()) SWIG_fail;
37430 }
37431 {
37432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37433 }
37434 return resultobj;
37435 fail:
37436 return NULL;
37437 }
37438
37439
37440 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37441 PyObject *resultobj = 0;
37442 wxWindow *arg1 = (wxWindow *) 0 ;
37443 bool result;
37444 void *argp1 = 0 ;
37445 int res1 = 0 ;
37446 PyObject *swig_obj[1] ;
37447
37448 if (!args) SWIG_fail;
37449 swig_obj[0] = args;
37450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 result = (bool)(arg1)->PageDown();
37458 wxPyEndAllowThreads(__tstate);
37459 if (PyErr_Occurred()) SWIG_fail;
37460 }
37461 {
37462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37463 }
37464 return resultobj;
37465 fail:
37466 return NULL;
37467 }
37468
37469
37470 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37471 PyObject *resultobj = 0;
37472 wxWindow *arg1 = (wxWindow *) 0 ;
37473 wxString *arg2 = 0 ;
37474 void *argp1 = 0 ;
37475 int res1 = 0 ;
37476 bool temp2 = false ;
37477 PyObject * obj0 = 0 ;
37478 PyObject * obj1 = 0 ;
37479 char * kwnames[] = {
37480 (char *) "self",(char *) "text", NULL
37481 };
37482
37483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37485 if (!SWIG_IsOK(res1)) {
37486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37487 }
37488 arg1 = reinterpret_cast< wxWindow * >(argp1);
37489 {
37490 arg2 = wxString_in_helper(obj1);
37491 if (arg2 == NULL) SWIG_fail;
37492 temp2 = true;
37493 }
37494 {
37495 PyThreadState* __tstate = wxPyBeginAllowThreads();
37496 (arg1)->SetHelpText((wxString const &)*arg2);
37497 wxPyEndAllowThreads(__tstate);
37498 if (PyErr_Occurred()) SWIG_fail;
37499 }
37500 resultobj = SWIG_Py_Void();
37501 {
37502 if (temp2)
37503 delete arg2;
37504 }
37505 return resultobj;
37506 fail:
37507 {
37508 if (temp2)
37509 delete arg2;
37510 }
37511 return NULL;
37512 }
37513
37514
37515 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37516 PyObject *resultobj = 0;
37517 wxWindow *arg1 = (wxWindow *) 0 ;
37518 wxString *arg2 = 0 ;
37519 void *argp1 = 0 ;
37520 int res1 = 0 ;
37521 bool temp2 = false ;
37522 PyObject * obj0 = 0 ;
37523 PyObject * obj1 = 0 ;
37524 char * kwnames[] = {
37525 (char *) "self",(char *) "text", NULL
37526 };
37527
37528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37530 if (!SWIG_IsOK(res1)) {
37531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37532 }
37533 arg1 = reinterpret_cast< wxWindow * >(argp1);
37534 {
37535 arg2 = wxString_in_helper(obj1);
37536 if (arg2 == NULL) SWIG_fail;
37537 temp2 = true;
37538 }
37539 {
37540 PyThreadState* __tstate = wxPyBeginAllowThreads();
37541 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37542 wxPyEndAllowThreads(__tstate);
37543 if (PyErr_Occurred()) SWIG_fail;
37544 }
37545 resultobj = SWIG_Py_Void();
37546 {
37547 if (temp2)
37548 delete arg2;
37549 }
37550 return resultobj;
37551 fail:
37552 {
37553 if (temp2)
37554 delete arg2;
37555 }
37556 return NULL;
37557 }
37558
37559
37560 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37561 PyObject *resultobj = 0;
37562 wxWindow *arg1 = (wxWindow *) 0 ;
37563 wxPoint *arg2 = 0 ;
37564 wxHelpEvent::Origin arg3 ;
37565 wxString result;
37566 void *argp1 = 0 ;
37567 int res1 = 0 ;
37568 wxPoint temp2 ;
37569 void *argp3 ;
37570 int res3 = 0 ;
37571 PyObject * obj0 = 0 ;
37572 PyObject * obj1 = 0 ;
37573 PyObject * obj2 = 0 ;
37574 char * kwnames[] = {
37575 (char *) "self",(char *) "pt",(char *) "origin", NULL
37576 };
37577
37578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37580 if (!SWIG_IsOK(res1)) {
37581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37582 }
37583 arg1 = reinterpret_cast< wxWindow * >(argp1);
37584 {
37585 arg2 = &temp2;
37586 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37587 }
37588 {
37589 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37590 if (!SWIG_IsOK(res3)) {
37591 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37592 }
37593 if (!argp3) {
37594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37595 } else {
37596 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37597 arg3 = *temp;
37598 if (SWIG_IsNewObj(res3)) delete temp;
37599 }
37600 }
37601 {
37602 PyThreadState* __tstate = wxPyBeginAllowThreads();
37603 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37604 wxPyEndAllowThreads(__tstate);
37605 if (PyErr_Occurred()) SWIG_fail;
37606 }
37607 {
37608 #if wxUSE_UNICODE
37609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37610 #else
37611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37612 #endif
37613 }
37614 return resultobj;
37615 fail:
37616 return NULL;
37617 }
37618
37619
37620 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37621 PyObject *resultobj = 0;
37622 wxWindow *arg1 = (wxWindow *) 0 ;
37623 wxString result;
37624 void *argp1 = 0 ;
37625 int res1 = 0 ;
37626 PyObject *swig_obj[1] ;
37627
37628 if (!args) SWIG_fail;
37629 swig_obj[0] = args;
37630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37631 if (!SWIG_IsOK(res1)) {
37632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37633 }
37634 arg1 = reinterpret_cast< wxWindow * >(argp1);
37635 {
37636 PyThreadState* __tstate = wxPyBeginAllowThreads();
37637 result = ((wxWindow const *)arg1)->GetHelpText();
37638 wxPyEndAllowThreads(__tstate);
37639 if (PyErr_Occurred()) SWIG_fail;
37640 }
37641 {
37642 #if wxUSE_UNICODE
37643 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37644 #else
37645 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37646 #endif
37647 }
37648 return resultobj;
37649 fail:
37650 return NULL;
37651 }
37652
37653
37654 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37655 PyObject *resultobj = 0;
37656 wxWindow *arg1 = (wxWindow *) 0 ;
37657 wxString *arg2 = 0 ;
37658 void *argp1 = 0 ;
37659 int res1 = 0 ;
37660 bool temp2 = false ;
37661 PyObject * obj0 = 0 ;
37662 PyObject * obj1 = 0 ;
37663 char * kwnames[] = {
37664 (char *) "self",(char *) "tip", NULL
37665 };
37666
37667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37669 if (!SWIG_IsOK(res1)) {
37670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37671 }
37672 arg1 = reinterpret_cast< wxWindow * >(argp1);
37673 {
37674 arg2 = wxString_in_helper(obj1);
37675 if (arg2 == NULL) SWIG_fail;
37676 temp2 = true;
37677 }
37678 {
37679 PyThreadState* __tstate = wxPyBeginAllowThreads();
37680 (arg1)->SetToolTip((wxString const &)*arg2);
37681 wxPyEndAllowThreads(__tstate);
37682 if (PyErr_Occurred()) SWIG_fail;
37683 }
37684 resultobj = SWIG_Py_Void();
37685 {
37686 if (temp2)
37687 delete arg2;
37688 }
37689 return resultobj;
37690 fail:
37691 {
37692 if (temp2)
37693 delete arg2;
37694 }
37695 return NULL;
37696 }
37697
37698
37699 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37700 PyObject *resultobj = 0;
37701 wxWindow *arg1 = (wxWindow *) 0 ;
37702 wxToolTip *arg2 = (wxToolTip *) 0 ;
37703 void *argp1 = 0 ;
37704 int res1 = 0 ;
37705 int res2 = 0 ;
37706 PyObject * obj0 = 0 ;
37707 PyObject * obj1 = 0 ;
37708 char * kwnames[] = {
37709 (char *) "self",(char *) "tip", NULL
37710 };
37711
37712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37714 if (!SWIG_IsOK(res1)) {
37715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37716 }
37717 arg1 = reinterpret_cast< wxWindow * >(argp1);
37718 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37719 if (!SWIG_IsOK(res2)) {
37720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37721 }
37722 {
37723 PyThreadState* __tstate = wxPyBeginAllowThreads();
37724 (arg1)->SetToolTip(arg2);
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 resultobj = SWIG_Py_Void();
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37736 PyObject *resultobj = 0;
37737 wxWindow *arg1 = (wxWindow *) 0 ;
37738 wxToolTip *result = 0 ;
37739 void *argp1 = 0 ;
37740 int res1 = 0 ;
37741 PyObject *swig_obj[1] ;
37742
37743 if (!args) SWIG_fail;
37744 swig_obj[0] = args;
37745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37746 if (!SWIG_IsOK(res1)) {
37747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37748 }
37749 arg1 = reinterpret_cast< wxWindow * >(argp1);
37750 {
37751 PyThreadState* __tstate = wxPyBeginAllowThreads();
37752 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37753 wxPyEndAllowThreads(__tstate);
37754 if (PyErr_Occurred()) SWIG_fail;
37755 }
37756 {
37757 resultobj = wxPyMake_wxObject(result, (bool)0);
37758 }
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37766 PyObject *resultobj = 0;
37767 wxWindow *arg1 = (wxWindow *) 0 ;
37768 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37769 void *argp1 = 0 ;
37770 int res1 = 0 ;
37771 int res2 = 0 ;
37772 PyObject * obj0 = 0 ;
37773 PyObject * obj1 = 0 ;
37774 char * kwnames[] = {
37775 (char *) "self",(char *) "dropTarget", NULL
37776 };
37777
37778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37780 if (!SWIG_IsOK(res1)) {
37781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37782 }
37783 arg1 = reinterpret_cast< wxWindow * >(argp1);
37784 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37785 if (!SWIG_IsOK(res2)) {
37786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37787 }
37788 {
37789 PyThreadState* __tstate = wxPyBeginAllowThreads();
37790 (arg1)->SetDropTarget(arg2);
37791 wxPyEndAllowThreads(__tstate);
37792 if (PyErr_Occurred()) SWIG_fail;
37793 }
37794 resultobj = SWIG_Py_Void();
37795 return resultobj;
37796 fail:
37797 return NULL;
37798 }
37799
37800
37801 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37802 PyObject *resultobj = 0;
37803 wxWindow *arg1 = (wxWindow *) 0 ;
37804 wxPyDropTarget *result = 0 ;
37805 void *argp1 = 0 ;
37806 int res1 = 0 ;
37807 PyObject *swig_obj[1] ;
37808
37809 if (!args) SWIG_fail;
37810 swig_obj[0] = args;
37811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37812 if (!SWIG_IsOK(res1)) {
37813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37814 }
37815 arg1 = reinterpret_cast< wxWindow * >(argp1);
37816 {
37817 PyThreadState* __tstate = wxPyBeginAllowThreads();
37818 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37819 wxPyEndAllowThreads(__tstate);
37820 if (PyErr_Occurred()) SWIG_fail;
37821 }
37822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37823 return resultobj;
37824 fail:
37825 return NULL;
37826 }
37827
37828
37829 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37830 PyObject *resultobj = 0;
37831 wxWindow *arg1 = (wxWindow *) 0 ;
37832 bool arg2 ;
37833 void *argp1 = 0 ;
37834 int res1 = 0 ;
37835 bool val2 ;
37836 int ecode2 = 0 ;
37837 PyObject * obj0 = 0 ;
37838 PyObject * obj1 = 0 ;
37839 char * kwnames[] = {
37840 (char *) "self",(char *) "accept", NULL
37841 };
37842
37843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37845 if (!SWIG_IsOK(res1)) {
37846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37847 }
37848 arg1 = reinterpret_cast< wxWindow * >(argp1);
37849 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37850 if (!SWIG_IsOK(ecode2)) {
37851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37852 }
37853 arg2 = static_cast< bool >(val2);
37854 {
37855 PyThreadState* __tstate = wxPyBeginAllowThreads();
37856 wxWindow_DragAcceptFiles(arg1,arg2);
37857 wxPyEndAllowThreads(__tstate);
37858 if (PyErr_Occurred()) SWIG_fail;
37859 }
37860 resultobj = SWIG_Py_Void();
37861 return resultobj;
37862 fail:
37863 return NULL;
37864 }
37865
37866
37867 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37868 PyObject *resultobj = 0;
37869 wxWindow *arg1 = (wxWindow *) 0 ;
37870 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37871 void *argp1 = 0 ;
37872 int res1 = 0 ;
37873 int res2 = 0 ;
37874 PyObject * obj0 = 0 ;
37875 PyObject * obj1 = 0 ;
37876 char * kwnames[] = {
37877 (char *) "self",(char *) "constraints", NULL
37878 };
37879
37880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37882 if (!SWIG_IsOK(res1)) {
37883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37884 }
37885 arg1 = reinterpret_cast< wxWindow * >(argp1);
37886 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37887 if (!SWIG_IsOK(res2)) {
37888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37889 }
37890 {
37891 PyThreadState* __tstate = wxPyBeginAllowThreads();
37892 (arg1)->SetConstraints(arg2);
37893 wxPyEndAllowThreads(__tstate);
37894 if (PyErr_Occurred()) SWIG_fail;
37895 }
37896 resultobj = SWIG_Py_Void();
37897 return resultobj;
37898 fail:
37899 return NULL;
37900 }
37901
37902
37903 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37904 PyObject *resultobj = 0;
37905 wxWindow *arg1 = (wxWindow *) 0 ;
37906 wxLayoutConstraints *result = 0 ;
37907 void *argp1 = 0 ;
37908 int res1 = 0 ;
37909 PyObject *swig_obj[1] ;
37910
37911 if (!args) SWIG_fail;
37912 swig_obj[0] = args;
37913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37914 if (!SWIG_IsOK(res1)) {
37915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37916 }
37917 arg1 = reinterpret_cast< wxWindow * >(argp1);
37918 {
37919 PyThreadState* __tstate = wxPyBeginAllowThreads();
37920 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37921 wxPyEndAllowThreads(__tstate);
37922 if (PyErr_Occurred()) SWIG_fail;
37923 }
37924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37925 return resultobj;
37926 fail:
37927 return NULL;
37928 }
37929
37930
37931 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37932 PyObject *resultobj = 0;
37933 wxWindow *arg1 = (wxWindow *) 0 ;
37934 bool arg2 ;
37935 void *argp1 = 0 ;
37936 int res1 = 0 ;
37937 bool val2 ;
37938 int ecode2 = 0 ;
37939 PyObject * obj0 = 0 ;
37940 PyObject * obj1 = 0 ;
37941 char * kwnames[] = {
37942 (char *) "self",(char *) "autoLayout", NULL
37943 };
37944
37945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37947 if (!SWIG_IsOK(res1)) {
37948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37949 }
37950 arg1 = reinterpret_cast< wxWindow * >(argp1);
37951 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37952 if (!SWIG_IsOK(ecode2)) {
37953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37954 }
37955 arg2 = static_cast< bool >(val2);
37956 {
37957 PyThreadState* __tstate = wxPyBeginAllowThreads();
37958 (arg1)->SetAutoLayout(arg2);
37959 wxPyEndAllowThreads(__tstate);
37960 if (PyErr_Occurred()) SWIG_fail;
37961 }
37962 resultobj = SWIG_Py_Void();
37963 return resultobj;
37964 fail:
37965 return NULL;
37966 }
37967
37968
37969 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37970 PyObject *resultobj = 0;
37971 wxWindow *arg1 = (wxWindow *) 0 ;
37972 bool result;
37973 void *argp1 = 0 ;
37974 int res1 = 0 ;
37975 PyObject *swig_obj[1] ;
37976
37977 if (!args) SWIG_fail;
37978 swig_obj[0] = args;
37979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37980 if (!SWIG_IsOK(res1)) {
37981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37982 }
37983 arg1 = reinterpret_cast< wxWindow * >(argp1);
37984 {
37985 PyThreadState* __tstate = wxPyBeginAllowThreads();
37986 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 {
37991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37992 }
37993 return resultobj;
37994 fail:
37995 return NULL;
37996 }
37997
37998
37999 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38000 PyObject *resultobj = 0;
38001 wxWindow *arg1 = (wxWindow *) 0 ;
38002 bool result;
38003 void *argp1 = 0 ;
38004 int res1 = 0 ;
38005 PyObject *swig_obj[1] ;
38006
38007 if (!args) SWIG_fail;
38008 swig_obj[0] = args;
38009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38010 if (!SWIG_IsOK(res1)) {
38011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38012 }
38013 arg1 = reinterpret_cast< wxWindow * >(argp1);
38014 {
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 result = (bool)(arg1)->Layout();
38017 wxPyEndAllowThreads(__tstate);
38018 if (PyErr_Occurred()) SWIG_fail;
38019 }
38020 {
38021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38022 }
38023 return resultobj;
38024 fail:
38025 return NULL;
38026 }
38027
38028
38029 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38030 PyObject *resultobj = 0;
38031 wxWindow *arg1 = (wxWindow *) 0 ;
38032 wxSizer *arg2 = (wxSizer *) 0 ;
38033 bool arg3 = (bool) true ;
38034 void *argp1 = 0 ;
38035 int res1 = 0 ;
38036 int res2 = 0 ;
38037 bool val3 ;
38038 int ecode3 = 0 ;
38039 PyObject * obj0 = 0 ;
38040 PyObject * obj1 = 0 ;
38041 PyObject * obj2 = 0 ;
38042 char * kwnames[] = {
38043 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38044 };
38045
38046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38048 if (!SWIG_IsOK(res1)) {
38049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38050 }
38051 arg1 = reinterpret_cast< wxWindow * >(argp1);
38052 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38053 if (!SWIG_IsOK(res2)) {
38054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38055 }
38056 if (obj2) {
38057 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38058 if (!SWIG_IsOK(ecode3)) {
38059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38060 }
38061 arg3 = static_cast< bool >(val3);
38062 }
38063 {
38064 PyThreadState* __tstate = wxPyBeginAllowThreads();
38065 (arg1)->SetSizer(arg2,arg3);
38066 wxPyEndAllowThreads(__tstate);
38067 if (PyErr_Occurred()) SWIG_fail;
38068 }
38069 resultobj = SWIG_Py_Void();
38070 return resultobj;
38071 fail:
38072 return NULL;
38073 }
38074
38075
38076 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38077 PyObject *resultobj = 0;
38078 wxWindow *arg1 = (wxWindow *) 0 ;
38079 wxSizer *arg2 = (wxSizer *) 0 ;
38080 bool arg3 = (bool) true ;
38081 void *argp1 = 0 ;
38082 int res1 = 0 ;
38083 int res2 = 0 ;
38084 bool val3 ;
38085 int ecode3 = 0 ;
38086 PyObject * obj0 = 0 ;
38087 PyObject * obj1 = 0 ;
38088 PyObject * obj2 = 0 ;
38089 char * kwnames[] = {
38090 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38091 };
38092
38093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38095 if (!SWIG_IsOK(res1)) {
38096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38097 }
38098 arg1 = reinterpret_cast< wxWindow * >(argp1);
38099 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38100 if (!SWIG_IsOK(res2)) {
38101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38102 }
38103 if (obj2) {
38104 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38105 if (!SWIG_IsOK(ecode3)) {
38106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38107 }
38108 arg3 = static_cast< bool >(val3);
38109 }
38110 {
38111 PyThreadState* __tstate = wxPyBeginAllowThreads();
38112 (arg1)->SetSizerAndFit(arg2,arg3);
38113 wxPyEndAllowThreads(__tstate);
38114 if (PyErr_Occurred()) SWIG_fail;
38115 }
38116 resultobj = SWIG_Py_Void();
38117 return resultobj;
38118 fail:
38119 return NULL;
38120 }
38121
38122
38123 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38124 PyObject *resultobj = 0;
38125 wxWindow *arg1 = (wxWindow *) 0 ;
38126 wxSizer *result = 0 ;
38127 void *argp1 = 0 ;
38128 int res1 = 0 ;
38129 PyObject *swig_obj[1] ;
38130
38131 if (!args) SWIG_fail;
38132 swig_obj[0] = args;
38133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38134 if (!SWIG_IsOK(res1)) {
38135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38136 }
38137 arg1 = reinterpret_cast< wxWindow * >(argp1);
38138 {
38139 PyThreadState* __tstate = wxPyBeginAllowThreads();
38140 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38141 wxPyEndAllowThreads(__tstate);
38142 if (PyErr_Occurred()) SWIG_fail;
38143 }
38144 {
38145 resultobj = wxPyMake_wxObject(result, (bool)0);
38146 }
38147 return resultobj;
38148 fail:
38149 return NULL;
38150 }
38151
38152
38153 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38154 PyObject *resultobj = 0;
38155 wxWindow *arg1 = (wxWindow *) 0 ;
38156 wxSizer *arg2 = (wxSizer *) 0 ;
38157 void *argp1 = 0 ;
38158 int res1 = 0 ;
38159 void *argp2 = 0 ;
38160 int res2 = 0 ;
38161 PyObject * obj0 = 0 ;
38162 PyObject * obj1 = 0 ;
38163 char * kwnames[] = {
38164 (char *) "self",(char *) "sizer", NULL
38165 };
38166
38167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38169 if (!SWIG_IsOK(res1)) {
38170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38171 }
38172 arg1 = reinterpret_cast< wxWindow * >(argp1);
38173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38174 if (!SWIG_IsOK(res2)) {
38175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38176 }
38177 arg2 = reinterpret_cast< wxSizer * >(argp2);
38178 {
38179 PyThreadState* __tstate = wxPyBeginAllowThreads();
38180 (arg1)->SetContainingSizer(arg2);
38181 wxPyEndAllowThreads(__tstate);
38182 if (PyErr_Occurred()) SWIG_fail;
38183 }
38184 resultobj = SWIG_Py_Void();
38185 return resultobj;
38186 fail:
38187 return NULL;
38188 }
38189
38190
38191 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38192 PyObject *resultobj = 0;
38193 wxWindow *arg1 = (wxWindow *) 0 ;
38194 wxSizer *result = 0 ;
38195 void *argp1 = 0 ;
38196 int res1 = 0 ;
38197 PyObject *swig_obj[1] ;
38198
38199 if (!args) SWIG_fail;
38200 swig_obj[0] = args;
38201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38202 if (!SWIG_IsOK(res1)) {
38203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38204 }
38205 arg1 = reinterpret_cast< wxWindow * >(argp1);
38206 {
38207 PyThreadState* __tstate = wxPyBeginAllowThreads();
38208 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38209 wxPyEndAllowThreads(__tstate);
38210 if (PyErr_Occurred()) SWIG_fail;
38211 }
38212 {
38213 resultobj = wxPyMake_wxObject(result, (bool)0);
38214 }
38215 return resultobj;
38216 fail:
38217 return NULL;
38218 }
38219
38220
38221 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38222 PyObject *resultobj = 0;
38223 wxWindow *arg1 = (wxWindow *) 0 ;
38224 void *argp1 = 0 ;
38225 int res1 = 0 ;
38226 PyObject *swig_obj[1] ;
38227
38228 if (!args) SWIG_fail;
38229 swig_obj[0] = args;
38230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38231 if (!SWIG_IsOK(res1)) {
38232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38233 }
38234 arg1 = reinterpret_cast< wxWindow * >(argp1);
38235 {
38236 PyThreadState* __tstate = wxPyBeginAllowThreads();
38237 (arg1)->InheritAttributes();
38238 wxPyEndAllowThreads(__tstate);
38239 if (PyErr_Occurred()) SWIG_fail;
38240 }
38241 resultobj = SWIG_Py_Void();
38242 return resultobj;
38243 fail:
38244 return NULL;
38245 }
38246
38247
38248 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38249 PyObject *resultobj = 0;
38250 wxWindow *arg1 = (wxWindow *) 0 ;
38251 bool result;
38252 void *argp1 = 0 ;
38253 int res1 = 0 ;
38254 PyObject *swig_obj[1] ;
38255
38256 if (!args) SWIG_fail;
38257 swig_obj[0] = args;
38258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38259 if (!SWIG_IsOK(res1)) {
38260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38261 }
38262 arg1 = reinterpret_cast< wxWindow * >(argp1);
38263 {
38264 PyThreadState* __tstate = wxPyBeginAllowThreads();
38265 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38266 wxPyEndAllowThreads(__tstate);
38267 if (PyErr_Occurred()) SWIG_fail;
38268 }
38269 {
38270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38271 }
38272 return resultobj;
38273 fail:
38274 return NULL;
38275 }
38276
38277
38278 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38279 PyObject *resultobj = 0;
38280 wxWindow *arg1 = (wxWindow *) 0 ;
38281 bool result;
38282 void *argp1 = 0 ;
38283 int res1 = 0 ;
38284 PyObject *swig_obj[1] ;
38285
38286 if (!args) SWIG_fail;
38287 swig_obj[0] = args;
38288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38289 if (!SWIG_IsOK(res1)) {
38290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38291 }
38292 arg1 = reinterpret_cast< wxWindow * >(argp1);
38293 {
38294 PyThreadState* __tstate = wxPyBeginAllowThreads();
38295 result = (bool)(arg1)->CanSetTransparent();
38296 wxPyEndAllowThreads(__tstate);
38297 if (PyErr_Occurred()) SWIG_fail;
38298 }
38299 {
38300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38301 }
38302 return resultobj;
38303 fail:
38304 return NULL;
38305 }
38306
38307
38308 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38309 PyObject *resultobj = 0;
38310 wxWindow *arg1 = (wxWindow *) 0 ;
38311 byte arg2 ;
38312 bool result;
38313 void *argp1 = 0 ;
38314 int res1 = 0 ;
38315 unsigned char val2 ;
38316 int ecode2 = 0 ;
38317 PyObject * obj0 = 0 ;
38318 PyObject * obj1 = 0 ;
38319 char * kwnames[] = {
38320 (char *) "self",(char *) "alpha", NULL
38321 };
38322
38323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38325 if (!SWIG_IsOK(res1)) {
38326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38327 }
38328 arg1 = reinterpret_cast< wxWindow * >(argp1);
38329 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38330 if (!SWIG_IsOK(ecode2)) {
38331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38332 }
38333 arg2 = static_cast< byte >(val2);
38334 {
38335 PyThreadState* __tstate = wxPyBeginAllowThreads();
38336 result = (bool)(arg1)->SetTransparent(arg2);
38337 wxPyEndAllowThreads(__tstate);
38338 if (PyErr_Occurred()) SWIG_fail;
38339 }
38340 {
38341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38342 }
38343 return resultobj;
38344 fail:
38345 return NULL;
38346 }
38347
38348
38349 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38350 PyObject *obj;
38351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38352 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38353 return SWIG_Py_Void();
38354 }
38355
38356 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38357 return SWIG_Python_InitShadowInstance(args);
38358 }
38359
38360 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38361 PyObject *resultobj = 0;
38362 long arg1 ;
38363 wxWindow *arg2 = (wxWindow *) NULL ;
38364 wxWindow *result = 0 ;
38365 long val1 ;
38366 int ecode1 = 0 ;
38367 void *argp2 = 0 ;
38368 int res2 = 0 ;
38369 PyObject * obj0 = 0 ;
38370 PyObject * obj1 = 0 ;
38371 char * kwnames[] = {
38372 (char *) "id",(char *) "parent", NULL
38373 };
38374
38375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38376 ecode1 = SWIG_AsVal_long(obj0, &val1);
38377 if (!SWIG_IsOK(ecode1)) {
38378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38379 }
38380 arg1 = static_cast< long >(val1);
38381 if (obj1) {
38382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38383 if (!SWIG_IsOK(res2)) {
38384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38385 }
38386 arg2 = reinterpret_cast< wxWindow * >(argp2);
38387 }
38388 {
38389 if (!wxPyCheckForApp()) SWIG_fail;
38390 PyThreadState* __tstate = wxPyBeginAllowThreads();
38391 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38392 wxPyEndAllowThreads(__tstate);
38393 if (PyErr_Occurred()) SWIG_fail;
38394 }
38395 {
38396 resultobj = wxPyMake_wxObject(result, 0);
38397 }
38398 return resultobj;
38399 fail:
38400 return NULL;
38401 }
38402
38403
38404 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38405 PyObject *resultobj = 0;
38406 wxString *arg1 = 0 ;
38407 wxWindow *arg2 = (wxWindow *) NULL ;
38408 wxWindow *result = 0 ;
38409 bool temp1 = false ;
38410 void *argp2 = 0 ;
38411 int res2 = 0 ;
38412 PyObject * obj0 = 0 ;
38413 PyObject * obj1 = 0 ;
38414 char * kwnames[] = {
38415 (char *) "name",(char *) "parent", NULL
38416 };
38417
38418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38419 {
38420 arg1 = wxString_in_helper(obj0);
38421 if (arg1 == NULL) SWIG_fail;
38422 temp1 = true;
38423 }
38424 if (obj1) {
38425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38426 if (!SWIG_IsOK(res2)) {
38427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38428 }
38429 arg2 = reinterpret_cast< wxWindow * >(argp2);
38430 }
38431 {
38432 if (!wxPyCheckForApp()) SWIG_fail;
38433 PyThreadState* __tstate = wxPyBeginAllowThreads();
38434 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38435 wxPyEndAllowThreads(__tstate);
38436 if (PyErr_Occurred()) SWIG_fail;
38437 }
38438 {
38439 resultobj = wxPyMake_wxObject(result, 0);
38440 }
38441 {
38442 if (temp1)
38443 delete arg1;
38444 }
38445 return resultobj;
38446 fail:
38447 {
38448 if (temp1)
38449 delete arg1;
38450 }
38451 return NULL;
38452 }
38453
38454
38455 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38456 PyObject *resultobj = 0;
38457 wxString *arg1 = 0 ;
38458 wxWindow *arg2 = (wxWindow *) NULL ;
38459 wxWindow *result = 0 ;
38460 bool temp1 = false ;
38461 void *argp2 = 0 ;
38462 int res2 = 0 ;
38463 PyObject * obj0 = 0 ;
38464 PyObject * obj1 = 0 ;
38465 char * kwnames[] = {
38466 (char *) "label",(char *) "parent", NULL
38467 };
38468
38469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38470 {
38471 arg1 = wxString_in_helper(obj0);
38472 if (arg1 == NULL) SWIG_fail;
38473 temp1 = true;
38474 }
38475 if (obj1) {
38476 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38477 if (!SWIG_IsOK(res2)) {
38478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38479 }
38480 arg2 = reinterpret_cast< wxWindow * >(argp2);
38481 }
38482 {
38483 if (!wxPyCheckForApp()) SWIG_fail;
38484 PyThreadState* __tstate = wxPyBeginAllowThreads();
38485 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38486 wxPyEndAllowThreads(__tstate);
38487 if (PyErr_Occurred()) SWIG_fail;
38488 }
38489 {
38490 resultobj = wxPyMake_wxObject(result, 0);
38491 }
38492 {
38493 if (temp1)
38494 delete arg1;
38495 }
38496 return resultobj;
38497 fail:
38498 {
38499 if (temp1)
38500 delete arg1;
38501 }
38502 return NULL;
38503 }
38504
38505
38506 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38507 PyObject *resultobj = 0;
38508 wxWindow *arg1 = (wxWindow *) 0 ;
38509 unsigned long arg2 ;
38510 wxWindow *result = 0 ;
38511 void *argp1 = 0 ;
38512 int res1 = 0 ;
38513 unsigned long val2 ;
38514 int ecode2 = 0 ;
38515 PyObject * obj0 = 0 ;
38516 PyObject * obj1 = 0 ;
38517 char * kwnames[] = {
38518 (char *) "parent",(char *) "_hWnd", NULL
38519 };
38520
38521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38523 if (!SWIG_IsOK(res1)) {
38524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38525 }
38526 arg1 = reinterpret_cast< wxWindow * >(argp1);
38527 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38528 if (!SWIG_IsOK(ecode2)) {
38529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38530 }
38531 arg2 = static_cast< unsigned long >(val2);
38532 {
38533 PyThreadState* __tstate = wxPyBeginAllowThreads();
38534 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38535 wxPyEndAllowThreads(__tstate);
38536 if (PyErr_Occurred()) SWIG_fail;
38537 }
38538 {
38539 resultobj = wxPyMake_wxObject(result, 0);
38540 }
38541 return resultobj;
38542 fail:
38543 return NULL;
38544 }
38545
38546
38547 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38548 PyObject *resultobj = 0;
38549 PyObject *result = 0 ;
38550
38551 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38552 {
38553 PyThreadState* __tstate = wxPyBeginAllowThreads();
38554 result = (PyObject *)GetTopLevelWindows();
38555 wxPyEndAllowThreads(__tstate);
38556 if (PyErr_Occurred()) SWIG_fail;
38557 }
38558 resultobj = result;
38559 return resultobj;
38560 fail:
38561 return NULL;
38562 }
38563
38564
38565 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38566 PyObject *resultobj = 0;
38567 wxValidator *result = 0 ;
38568
38569 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38570 {
38571 PyThreadState* __tstate = wxPyBeginAllowThreads();
38572 result = (wxValidator *)new wxValidator();
38573 wxPyEndAllowThreads(__tstate);
38574 if (PyErr_Occurred()) SWIG_fail;
38575 }
38576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38577 return resultobj;
38578 fail:
38579 return NULL;
38580 }
38581
38582
38583 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38584 PyObject *resultobj = 0;
38585 wxValidator *arg1 = (wxValidator *) 0 ;
38586 wxValidator *result = 0 ;
38587 void *argp1 = 0 ;
38588 int res1 = 0 ;
38589 PyObject *swig_obj[1] ;
38590
38591 if (!args) SWIG_fail;
38592 swig_obj[0] = args;
38593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38594 if (!SWIG_IsOK(res1)) {
38595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38596 }
38597 arg1 = reinterpret_cast< wxValidator * >(argp1);
38598 {
38599 PyThreadState* __tstate = wxPyBeginAllowThreads();
38600 result = (wxValidator *)(arg1)->Clone();
38601 wxPyEndAllowThreads(__tstate);
38602 if (PyErr_Occurred()) SWIG_fail;
38603 }
38604 {
38605 resultobj = wxPyMake_wxObject(result, 0);
38606 }
38607 return resultobj;
38608 fail:
38609 return NULL;
38610 }
38611
38612
38613 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38614 PyObject *resultobj = 0;
38615 wxValidator *arg1 = (wxValidator *) 0 ;
38616 wxWindow *arg2 = (wxWindow *) 0 ;
38617 bool result;
38618 void *argp1 = 0 ;
38619 int res1 = 0 ;
38620 void *argp2 = 0 ;
38621 int res2 = 0 ;
38622 PyObject * obj0 = 0 ;
38623 PyObject * obj1 = 0 ;
38624 char * kwnames[] = {
38625 (char *) "self",(char *) "parent", NULL
38626 };
38627
38628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38630 if (!SWIG_IsOK(res1)) {
38631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38632 }
38633 arg1 = reinterpret_cast< wxValidator * >(argp1);
38634 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38635 if (!SWIG_IsOK(res2)) {
38636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38637 }
38638 arg2 = reinterpret_cast< wxWindow * >(argp2);
38639 {
38640 PyThreadState* __tstate = wxPyBeginAllowThreads();
38641 result = (bool)(arg1)->Validate(arg2);
38642 wxPyEndAllowThreads(__tstate);
38643 if (PyErr_Occurred()) SWIG_fail;
38644 }
38645 {
38646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38647 }
38648 return resultobj;
38649 fail:
38650 return NULL;
38651 }
38652
38653
38654 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38655 PyObject *resultobj = 0;
38656 wxValidator *arg1 = (wxValidator *) 0 ;
38657 bool result;
38658 void *argp1 = 0 ;
38659 int res1 = 0 ;
38660 PyObject *swig_obj[1] ;
38661
38662 if (!args) SWIG_fail;
38663 swig_obj[0] = args;
38664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38665 if (!SWIG_IsOK(res1)) {
38666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38667 }
38668 arg1 = reinterpret_cast< wxValidator * >(argp1);
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 result = (bool)(arg1)->TransferToWindow();
38672 wxPyEndAllowThreads(__tstate);
38673 if (PyErr_Occurred()) SWIG_fail;
38674 }
38675 {
38676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38677 }
38678 return resultobj;
38679 fail:
38680 return NULL;
38681 }
38682
38683
38684 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38685 PyObject *resultobj = 0;
38686 wxValidator *arg1 = (wxValidator *) 0 ;
38687 bool result;
38688 void *argp1 = 0 ;
38689 int res1 = 0 ;
38690 PyObject *swig_obj[1] ;
38691
38692 if (!args) SWIG_fail;
38693 swig_obj[0] = args;
38694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38695 if (!SWIG_IsOK(res1)) {
38696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38697 }
38698 arg1 = reinterpret_cast< wxValidator * >(argp1);
38699 {
38700 PyThreadState* __tstate = wxPyBeginAllowThreads();
38701 result = (bool)(arg1)->TransferFromWindow();
38702 wxPyEndAllowThreads(__tstate);
38703 if (PyErr_Occurred()) SWIG_fail;
38704 }
38705 {
38706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38707 }
38708 return resultobj;
38709 fail:
38710 return NULL;
38711 }
38712
38713
38714 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38715 PyObject *resultobj = 0;
38716 wxValidator *arg1 = (wxValidator *) 0 ;
38717 wxWindow *result = 0 ;
38718 void *argp1 = 0 ;
38719 int res1 = 0 ;
38720 PyObject *swig_obj[1] ;
38721
38722 if (!args) SWIG_fail;
38723 swig_obj[0] = args;
38724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38725 if (!SWIG_IsOK(res1)) {
38726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38727 }
38728 arg1 = reinterpret_cast< wxValidator * >(argp1);
38729 {
38730 PyThreadState* __tstate = wxPyBeginAllowThreads();
38731 result = (wxWindow *)(arg1)->GetWindow();
38732 wxPyEndAllowThreads(__tstate);
38733 if (PyErr_Occurred()) SWIG_fail;
38734 }
38735 {
38736 resultobj = wxPyMake_wxObject(result, 0);
38737 }
38738 return resultobj;
38739 fail:
38740 return NULL;
38741 }
38742
38743
38744 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38745 PyObject *resultobj = 0;
38746 wxValidator *arg1 = (wxValidator *) 0 ;
38747 wxWindow *arg2 = (wxWindow *) 0 ;
38748 void *argp1 = 0 ;
38749 int res1 = 0 ;
38750 void *argp2 = 0 ;
38751 int res2 = 0 ;
38752 PyObject * obj0 = 0 ;
38753 PyObject * obj1 = 0 ;
38754 char * kwnames[] = {
38755 (char *) "self",(char *) "window", NULL
38756 };
38757
38758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38760 if (!SWIG_IsOK(res1)) {
38761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38762 }
38763 arg1 = reinterpret_cast< wxValidator * >(argp1);
38764 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38765 if (!SWIG_IsOK(res2)) {
38766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38767 }
38768 arg2 = reinterpret_cast< wxWindow * >(argp2);
38769 {
38770 PyThreadState* __tstate = wxPyBeginAllowThreads();
38771 (arg1)->SetWindow(arg2);
38772 wxPyEndAllowThreads(__tstate);
38773 if (PyErr_Occurred()) SWIG_fail;
38774 }
38775 resultobj = SWIG_Py_Void();
38776 return resultobj;
38777 fail:
38778 return NULL;
38779 }
38780
38781
38782 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38783 PyObject *resultobj = 0;
38784 bool result;
38785
38786 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38787 {
38788 PyThreadState* __tstate = wxPyBeginAllowThreads();
38789 result = (bool)wxValidator::IsSilent();
38790 wxPyEndAllowThreads(__tstate);
38791 if (PyErr_Occurred()) SWIG_fail;
38792 }
38793 {
38794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38795 }
38796 return resultobj;
38797 fail:
38798 return NULL;
38799 }
38800
38801
38802 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38803 PyObject *resultobj = 0;
38804 int arg1 = (int) true ;
38805 int val1 ;
38806 int ecode1 = 0 ;
38807 PyObject * obj0 = 0 ;
38808 char * kwnames[] = {
38809 (char *) "doIt", NULL
38810 };
38811
38812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38813 if (obj0) {
38814 ecode1 = SWIG_AsVal_int(obj0, &val1);
38815 if (!SWIG_IsOK(ecode1)) {
38816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38817 }
38818 arg1 = static_cast< int >(val1);
38819 }
38820 {
38821 PyThreadState* __tstate = wxPyBeginAllowThreads();
38822 wxValidator::SetBellOnError(arg1);
38823 wxPyEndAllowThreads(__tstate);
38824 if (PyErr_Occurred()) SWIG_fail;
38825 }
38826 resultobj = SWIG_Py_Void();
38827 return resultobj;
38828 fail:
38829 return NULL;
38830 }
38831
38832
38833 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38834 PyObject *obj;
38835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38836 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38837 return SWIG_Py_Void();
38838 }
38839
38840 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38841 return SWIG_Python_InitShadowInstance(args);
38842 }
38843
38844 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38845 PyObject *resultobj = 0;
38846 wxPyValidator *result = 0 ;
38847
38848 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38849 {
38850 PyThreadState* __tstate = wxPyBeginAllowThreads();
38851 result = (wxPyValidator *)new wxPyValidator();
38852 wxPyEndAllowThreads(__tstate);
38853 if (PyErr_Occurred()) SWIG_fail;
38854 }
38855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38856 return resultobj;
38857 fail:
38858 return NULL;
38859 }
38860
38861
38862 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38863 PyObject *resultobj = 0;
38864 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38865 PyObject *arg2 = (PyObject *) 0 ;
38866 PyObject *arg3 = (PyObject *) 0 ;
38867 int arg4 = (int) true ;
38868 void *argp1 = 0 ;
38869 int res1 = 0 ;
38870 int val4 ;
38871 int ecode4 = 0 ;
38872 PyObject * obj0 = 0 ;
38873 PyObject * obj1 = 0 ;
38874 PyObject * obj2 = 0 ;
38875 PyObject * obj3 = 0 ;
38876 char * kwnames[] = {
38877 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38878 };
38879
38880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38882 if (!SWIG_IsOK(res1)) {
38883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38884 }
38885 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38886 arg2 = obj1;
38887 arg3 = obj2;
38888 if (obj3) {
38889 ecode4 = SWIG_AsVal_int(obj3, &val4);
38890 if (!SWIG_IsOK(ecode4)) {
38891 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38892 }
38893 arg4 = static_cast< int >(val4);
38894 }
38895 {
38896 PyThreadState* __tstate = wxPyBeginAllowThreads();
38897 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38898 wxPyEndAllowThreads(__tstate);
38899 if (PyErr_Occurred()) SWIG_fail;
38900 }
38901 resultobj = SWIG_Py_Void();
38902 return resultobj;
38903 fail:
38904 return NULL;
38905 }
38906
38907
38908 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38909 PyObject *obj;
38910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38911 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38912 return SWIG_Py_Void();
38913 }
38914
38915 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38916 return SWIG_Python_InitShadowInstance(args);
38917 }
38918
38919 SWIGINTERN int DefaultValidator_set(PyObject *) {
38920 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38921 return 1;
38922 }
38923
38924
38925 SWIGINTERN PyObject *DefaultValidator_get(void) {
38926 PyObject *pyobj = 0;
38927
38928 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38929 return pyobj;
38930 }
38931
38932
38933 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38934 PyObject *resultobj = 0;
38935 wxString const &arg1_defvalue = wxPyEmptyString ;
38936 wxString *arg1 = (wxString *) &arg1_defvalue ;
38937 long arg2 = (long) 0 ;
38938 wxMenu *result = 0 ;
38939 bool temp1 = false ;
38940 long val2 ;
38941 int ecode2 = 0 ;
38942 PyObject * obj0 = 0 ;
38943 PyObject * obj1 = 0 ;
38944 char * kwnames[] = {
38945 (char *) "title",(char *) "style", NULL
38946 };
38947
38948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38949 if (obj0) {
38950 {
38951 arg1 = wxString_in_helper(obj0);
38952 if (arg1 == NULL) SWIG_fail;
38953 temp1 = true;
38954 }
38955 }
38956 if (obj1) {
38957 ecode2 = SWIG_AsVal_long(obj1, &val2);
38958 if (!SWIG_IsOK(ecode2)) {
38959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38960 }
38961 arg2 = static_cast< long >(val2);
38962 }
38963 {
38964 if (!wxPyCheckForApp()) SWIG_fail;
38965 PyThreadState* __tstate = wxPyBeginAllowThreads();
38966 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38967 wxPyEndAllowThreads(__tstate);
38968 if (PyErr_Occurred()) SWIG_fail;
38969 }
38970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38971 {
38972 if (temp1)
38973 delete arg1;
38974 }
38975 return resultobj;
38976 fail:
38977 {
38978 if (temp1)
38979 delete arg1;
38980 }
38981 return NULL;
38982 }
38983
38984
38985 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38986 PyObject *resultobj = 0;
38987 wxMenu *arg1 = (wxMenu *) 0 ;
38988 int arg2 ;
38989 wxString const &arg3_defvalue = wxPyEmptyString ;
38990 wxString *arg3 = (wxString *) &arg3_defvalue ;
38991 wxString const &arg4_defvalue = wxPyEmptyString ;
38992 wxString *arg4 = (wxString *) &arg4_defvalue ;
38993 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38994 wxMenuItem *result = 0 ;
38995 void *argp1 = 0 ;
38996 int res1 = 0 ;
38997 int val2 ;
38998 int ecode2 = 0 ;
38999 bool temp3 = false ;
39000 bool temp4 = false ;
39001 int val5 ;
39002 int ecode5 = 0 ;
39003 PyObject * obj0 = 0 ;
39004 PyObject * obj1 = 0 ;
39005 PyObject * obj2 = 0 ;
39006 PyObject * obj3 = 0 ;
39007 PyObject * obj4 = 0 ;
39008 char * kwnames[] = {
39009 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39010 };
39011
39012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39014 if (!SWIG_IsOK(res1)) {
39015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39016 }
39017 arg1 = reinterpret_cast< wxMenu * >(argp1);
39018 ecode2 = SWIG_AsVal_int(obj1, &val2);
39019 if (!SWIG_IsOK(ecode2)) {
39020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39021 }
39022 arg2 = static_cast< int >(val2);
39023 if (obj2) {
39024 {
39025 arg3 = wxString_in_helper(obj2);
39026 if (arg3 == NULL) SWIG_fail;
39027 temp3 = true;
39028 }
39029 }
39030 if (obj3) {
39031 {
39032 arg4 = wxString_in_helper(obj3);
39033 if (arg4 == NULL) SWIG_fail;
39034 temp4 = true;
39035 }
39036 }
39037 if (obj4) {
39038 ecode5 = SWIG_AsVal_int(obj4, &val5);
39039 if (!SWIG_IsOK(ecode5)) {
39040 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39041 }
39042 arg5 = static_cast< wxItemKind >(val5);
39043 }
39044 {
39045 PyThreadState* __tstate = wxPyBeginAllowThreads();
39046 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39047 wxPyEndAllowThreads(__tstate);
39048 if (PyErr_Occurred()) SWIG_fail;
39049 }
39050 {
39051 resultobj = wxPyMake_wxObject(result, (bool)0);
39052 }
39053 {
39054 if (temp3)
39055 delete arg3;
39056 }
39057 {
39058 if (temp4)
39059 delete arg4;
39060 }
39061 return resultobj;
39062 fail:
39063 {
39064 if (temp3)
39065 delete arg3;
39066 }
39067 {
39068 if (temp4)
39069 delete arg4;
39070 }
39071 return NULL;
39072 }
39073
39074
39075 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39076 PyObject *resultobj = 0;
39077 wxMenu *arg1 = (wxMenu *) 0 ;
39078 wxMenuItem *result = 0 ;
39079 void *argp1 = 0 ;
39080 int res1 = 0 ;
39081 PyObject *swig_obj[1] ;
39082
39083 if (!args) SWIG_fail;
39084 swig_obj[0] = args;
39085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39086 if (!SWIG_IsOK(res1)) {
39087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39088 }
39089 arg1 = reinterpret_cast< wxMenu * >(argp1);
39090 {
39091 PyThreadState* __tstate = wxPyBeginAllowThreads();
39092 result = (wxMenuItem *)(arg1)->AppendSeparator();
39093 wxPyEndAllowThreads(__tstate);
39094 if (PyErr_Occurred()) SWIG_fail;
39095 }
39096 {
39097 resultobj = wxPyMake_wxObject(result, (bool)0);
39098 }
39099 return resultobj;
39100 fail:
39101 return NULL;
39102 }
39103
39104
39105 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39106 PyObject *resultobj = 0;
39107 wxMenu *arg1 = (wxMenu *) 0 ;
39108 int arg2 ;
39109 wxString *arg3 = 0 ;
39110 wxString const &arg4_defvalue = wxPyEmptyString ;
39111 wxString *arg4 = (wxString *) &arg4_defvalue ;
39112 wxMenuItem *result = 0 ;
39113 void *argp1 = 0 ;
39114 int res1 = 0 ;
39115 int val2 ;
39116 int ecode2 = 0 ;
39117 bool temp3 = false ;
39118 bool temp4 = false ;
39119 PyObject * obj0 = 0 ;
39120 PyObject * obj1 = 0 ;
39121 PyObject * obj2 = 0 ;
39122 PyObject * obj3 = 0 ;
39123 char * kwnames[] = {
39124 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39125 };
39126
39127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39129 if (!SWIG_IsOK(res1)) {
39130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39131 }
39132 arg1 = reinterpret_cast< wxMenu * >(argp1);
39133 ecode2 = SWIG_AsVal_int(obj1, &val2);
39134 if (!SWIG_IsOK(ecode2)) {
39135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39136 }
39137 arg2 = static_cast< int >(val2);
39138 {
39139 arg3 = wxString_in_helper(obj2);
39140 if (arg3 == NULL) SWIG_fail;
39141 temp3 = true;
39142 }
39143 if (obj3) {
39144 {
39145 arg4 = wxString_in_helper(obj3);
39146 if (arg4 == NULL) SWIG_fail;
39147 temp4 = true;
39148 }
39149 }
39150 {
39151 PyThreadState* __tstate = wxPyBeginAllowThreads();
39152 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39153 wxPyEndAllowThreads(__tstate);
39154 if (PyErr_Occurred()) SWIG_fail;
39155 }
39156 {
39157 resultobj = wxPyMake_wxObject(result, (bool)0);
39158 }
39159 {
39160 if (temp3)
39161 delete arg3;
39162 }
39163 {
39164 if (temp4)
39165 delete arg4;
39166 }
39167 return resultobj;
39168 fail:
39169 {
39170 if (temp3)
39171 delete arg3;
39172 }
39173 {
39174 if (temp4)
39175 delete arg4;
39176 }
39177 return NULL;
39178 }
39179
39180
39181 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39182 PyObject *resultobj = 0;
39183 wxMenu *arg1 = (wxMenu *) 0 ;
39184 int arg2 ;
39185 wxString *arg3 = 0 ;
39186 wxString const &arg4_defvalue = wxPyEmptyString ;
39187 wxString *arg4 = (wxString *) &arg4_defvalue ;
39188 wxMenuItem *result = 0 ;
39189 void *argp1 = 0 ;
39190 int res1 = 0 ;
39191 int val2 ;
39192 int ecode2 = 0 ;
39193 bool temp3 = false ;
39194 bool temp4 = false ;
39195 PyObject * obj0 = 0 ;
39196 PyObject * obj1 = 0 ;
39197 PyObject * obj2 = 0 ;
39198 PyObject * obj3 = 0 ;
39199 char * kwnames[] = {
39200 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39201 };
39202
39203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39205 if (!SWIG_IsOK(res1)) {
39206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39207 }
39208 arg1 = reinterpret_cast< wxMenu * >(argp1);
39209 ecode2 = SWIG_AsVal_int(obj1, &val2);
39210 if (!SWIG_IsOK(ecode2)) {
39211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39212 }
39213 arg2 = static_cast< int >(val2);
39214 {
39215 arg3 = wxString_in_helper(obj2);
39216 if (arg3 == NULL) SWIG_fail;
39217 temp3 = true;
39218 }
39219 if (obj3) {
39220 {
39221 arg4 = wxString_in_helper(obj3);
39222 if (arg4 == NULL) SWIG_fail;
39223 temp4 = true;
39224 }
39225 }
39226 {
39227 PyThreadState* __tstate = wxPyBeginAllowThreads();
39228 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39229 wxPyEndAllowThreads(__tstate);
39230 if (PyErr_Occurred()) SWIG_fail;
39231 }
39232 {
39233 resultobj = wxPyMake_wxObject(result, (bool)0);
39234 }
39235 {
39236 if (temp3)
39237 delete arg3;
39238 }
39239 {
39240 if (temp4)
39241 delete arg4;
39242 }
39243 return resultobj;
39244 fail:
39245 {
39246 if (temp3)
39247 delete arg3;
39248 }
39249 {
39250 if (temp4)
39251 delete arg4;
39252 }
39253 return NULL;
39254 }
39255
39256
39257 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39258 PyObject *resultobj = 0;
39259 wxMenu *arg1 = (wxMenu *) 0 ;
39260 int arg2 ;
39261 wxString *arg3 = 0 ;
39262 wxMenu *arg4 = (wxMenu *) 0 ;
39263 wxString const &arg5_defvalue = wxPyEmptyString ;
39264 wxString *arg5 = (wxString *) &arg5_defvalue ;
39265 wxMenuItem *result = 0 ;
39266 void *argp1 = 0 ;
39267 int res1 = 0 ;
39268 int val2 ;
39269 int ecode2 = 0 ;
39270 bool temp3 = false ;
39271 void *argp4 = 0 ;
39272 int res4 = 0 ;
39273 bool temp5 = false ;
39274 PyObject * obj0 = 0 ;
39275 PyObject * obj1 = 0 ;
39276 PyObject * obj2 = 0 ;
39277 PyObject * obj3 = 0 ;
39278 PyObject * obj4 = 0 ;
39279 char * kwnames[] = {
39280 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39281 };
39282
39283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39285 if (!SWIG_IsOK(res1)) {
39286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39287 }
39288 arg1 = reinterpret_cast< wxMenu * >(argp1);
39289 ecode2 = SWIG_AsVal_int(obj1, &val2);
39290 if (!SWIG_IsOK(ecode2)) {
39291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39292 }
39293 arg2 = static_cast< int >(val2);
39294 {
39295 arg3 = wxString_in_helper(obj2);
39296 if (arg3 == NULL) SWIG_fail;
39297 temp3 = true;
39298 }
39299 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39300 if (!SWIG_IsOK(res4)) {
39301 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39302 }
39303 arg4 = reinterpret_cast< wxMenu * >(argp4);
39304 if (obj4) {
39305 {
39306 arg5 = wxString_in_helper(obj4);
39307 if (arg5 == NULL) SWIG_fail;
39308 temp5 = true;
39309 }
39310 }
39311 {
39312 PyThreadState* __tstate = wxPyBeginAllowThreads();
39313 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39314 wxPyEndAllowThreads(__tstate);
39315 if (PyErr_Occurred()) SWIG_fail;
39316 }
39317 {
39318 resultobj = wxPyMake_wxObject(result, (bool)0);
39319 }
39320 {
39321 if (temp3)
39322 delete arg3;
39323 }
39324 {
39325 if (temp5)
39326 delete arg5;
39327 }
39328 return resultobj;
39329 fail:
39330 {
39331 if (temp3)
39332 delete arg3;
39333 }
39334 {
39335 if (temp5)
39336 delete arg5;
39337 }
39338 return NULL;
39339 }
39340
39341
39342 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39343 PyObject *resultobj = 0;
39344 wxMenu *arg1 = (wxMenu *) 0 ;
39345 wxMenu *arg2 = (wxMenu *) 0 ;
39346 wxString *arg3 = 0 ;
39347 wxString const &arg4_defvalue = wxPyEmptyString ;
39348 wxString *arg4 = (wxString *) &arg4_defvalue ;
39349 wxMenuItem *result = 0 ;
39350 void *argp1 = 0 ;
39351 int res1 = 0 ;
39352 void *argp2 = 0 ;
39353 int res2 = 0 ;
39354 bool temp3 = false ;
39355 bool temp4 = false ;
39356 PyObject * obj0 = 0 ;
39357 PyObject * obj1 = 0 ;
39358 PyObject * obj2 = 0 ;
39359 PyObject * obj3 = 0 ;
39360 char * kwnames[] = {
39361 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39362 };
39363
39364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39366 if (!SWIG_IsOK(res1)) {
39367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39368 }
39369 arg1 = reinterpret_cast< wxMenu * >(argp1);
39370 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39371 if (!SWIG_IsOK(res2)) {
39372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39373 }
39374 arg2 = reinterpret_cast< wxMenu * >(argp2);
39375 {
39376 arg3 = wxString_in_helper(obj2);
39377 if (arg3 == NULL) SWIG_fail;
39378 temp3 = true;
39379 }
39380 if (obj3) {
39381 {
39382 arg4 = wxString_in_helper(obj3);
39383 if (arg4 == NULL) SWIG_fail;
39384 temp4 = true;
39385 }
39386 }
39387 {
39388 PyThreadState* __tstate = wxPyBeginAllowThreads();
39389 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39390 wxPyEndAllowThreads(__tstate);
39391 if (PyErr_Occurred()) SWIG_fail;
39392 }
39393 {
39394 resultobj = wxPyMake_wxObject(result, (bool)0);
39395 }
39396 {
39397 if (temp3)
39398 delete arg3;
39399 }
39400 {
39401 if (temp4)
39402 delete arg4;
39403 }
39404 return resultobj;
39405 fail:
39406 {
39407 if (temp3)
39408 delete arg3;
39409 }
39410 {
39411 if (temp4)
39412 delete arg4;
39413 }
39414 return NULL;
39415 }
39416
39417
39418 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39419 PyObject *resultobj = 0;
39420 wxMenu *arg1 = (wxMenu *) 0 ;
39421 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39422 wxMenuItem *result = 0 ;
39423 void *argp1 = 0 ;
39424 int res1 = 0 ;
39425 int res2 = 0 ;
39426 PyObject * obj0 = 0 ;
39427 PyObject * obj1 = 0 ;
39428 char * kwnames[] = {
39429 (char *) "self",(char *) "item", NULL
39430 };
39431
39432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39434 if (!SWIG_IsOK(res1)) {
39435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39436 }
39437 arg1 = reinterpret_cast< wxMenu * >(argp1);
39438 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39439 if (!SWIG_IsOK(res2)) {
39440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39441 }
39442 {
39443 PyThreadState* __tstate = wxPyBeginAllowThreads();
39444 result = (wxMenuItem *)(arg1)->Append(arg2);
39445 wxPyEndAllowThreads(__tstate);
39446 if (PyErr_Occurred()) SWIG_fail;
39447 }
39448 {
39449 resultobj = wxPyMake_wxObject(result, (bool)0);
39450 }
39451 return resultobj;
39452 fail:
39453 return NULL;
39454 }
39455
39456
39457 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39458 PyObject *resultobj = 0;
39459 wxMenu *arg1 = (wxMenu *) 0 ;
39460 size_t arg2 ;
39461 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39462 wxMenuItem *result = 0 ;
39463 void *argp1 = 0 ;
39464 int res1 = 0 ;
39465 size_t val2 ;
39466 int ecode2 = 0 ;
39467 int res3 = 0 ;
39468 PyObject * obj0 = 0 ;
39469 PyObject * obj1 = 0 ;
39470 PyObject * obj2 = 0 ;
39471 char * kwnames[] = {
39472 (char *) "self",(char *) "pos",(char *) "item", NULL
39473 };
39474
39475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39477 if (!SWIG_IsOK(res1)) {
39478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39479 }
39480 arg1 = reinterpret_cast< wxMenu * >(argp1);
39481 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39482 if (!SWIG_IsOK(ecode2)) {
39483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39484 }
39485 arg2 = static_cast< size_t >(val2);
39486 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39487 if (!SWIG_IsOK(res3)) {
39488 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39489 }
39490 {
39491 PyThreadState* __tstate = wxPyBeginAllowThreads();
39492 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39493 wxPyEndAllowThreads(__tstate);
39494 if (PyErr_Occurred()) SWIG_fail;
39495 }
39496 {
39497 resultobj = wxPyMake_wxObject(result, (bool)0);
39498 }
39499 return resultobj;
39500 fail:
39501 return NULL;
39502 }
39503
39504
39505 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39506 PyObject *resultobj = 0;
39507 wxMenu *arg1 = (wxMenu *) 0 ;
39508 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39509 wxMenuItem *result = 0 ;
39510 void *argp1 = 0 ;
39511 int res1 = 0 ;
39512 int res2 = 0 ;
39513 PyObject * obj0 = 0 ;
39514 PyObject * obj1 = 0 ;
39515 char * kwnames[] = {
39516 (char *) "self",(char *) "item", NULL
39517 };
39518
39519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39521 if (!SWIG_IsOK(res1)) {
39522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39523 }
39524 arg1 = reinterpret_cast< wxMenu * >(argp1);
39525 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39526 if (!SWIG_IsOK(res2)) {
39527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39528 }
39529 {
39530 PyThreadState* __tstate = wxPyBeginAllowThreads();
39531 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39532 wxPyEndAllowThreads(__tstate);
39533 if (PyErr_Occurred()) SWIG_fail;
39534 }
39535 {
39536 resultobj = wxPyMake_wxObject(result, (bool)0);
39537 }
39538 return resultobj;
39539 fail:
39540 return NULL;
39541 }
39542
39543
39544 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39545 PyObject *resultobj = 0;
39546 wxMenu *arg1 = (wxMenu *) 0 ;
39547 void *argp1 = 0 ;
39548 int res1 = 0 ;
39549 PyObject *swig_obj[1] ;
39550
39551 if (!args) SWIG_fail;
39552 swig_obj[0] = args;
39553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39554 if (!SWIG_IsOK(res1)) {
39555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39556 }
39557 arg1 = reinterpret_cast< wxMenu * >(argp1);
39558 {
39559 PyThreadState* __tstate = wxPyBeginAllowThreads();
39560 (arg1)->Break();
39561 wxPyEndAllowThreads(__tstate);
39562 if (PyErr_Occurred()) SWIG_fail;
39563 }
39564 resultobj = SWIG_Py_Void();
39565 return resultobj;
39566 fail:
39567 return NULL;
39568 }
39569
39570
39571 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39572 PyObject *resultobj = 0;
39573 wxMenu *arg1 = (wxMenu *) 0 ;
39574 size_t arg2 ;
39575 int arg3 ;
39576 wxString const &arg4_defvalue = wxPyEmptyString ;
39577 wxString *arg4 = (wxString *) &arg4_defvalue ;
39578 wxString const &arg5_defvalue = wxPyEmptyString ;
39579 wxString *arg5 = (wxString *) &arg5_defvalue ;
39580 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39581 wxMenuItem *result = 0 ;
39582 void *argp1 = 0 ;
39583 int res1 = 0 ;
39584 size_t val2 ;
39585 int ecode2 = 0 ;
39586 int val3 ;
39587 int ecode3 = 0 ;
39588 bool temp4 = false ;
39589 bool temp5 = false ;
39590 int val6 ;
39591 int ecode6 = 0 ;
39592 PyObject * obj0 = 0 ;
39593 PyObject * obj1 = 0 ;
39594 PyObject * obj2 = 0 ;
39595 PyObject * obj3 = 0 ;
39596 PyObject * obj4 = 0 ;
39597 PyObject * obj5 = 0 ;
39598 char * kwnames[] = {
39599 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39600 };
39601
39602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39604 if (!SWIG_IsOK(res1)) {
39605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39606 }
39607 arg1 = reinterpret_cast< wxMenu * >(argp1);
39608 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39609 if (!SWIG_IsOK(ecode2)) {
39610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39611 }
39612 arg2 = static_cast< size_t >(val2);
39613 ecode3 = SWIG_AsVal_int(obj2, &val3);
39614 if (!SWIG_IsOK(ecode3)) {
39615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39616 }
39617 arg3 = static_cast< int >(val3);
39618 if (obj3) {
39619 {
39620 arg4 = wxString_in_helper(obj3);
39621 if (arg4 == NULL) SWIG_fail;
39622 temp4 = true;
39623 }
39624 }
39625 if (obj4) {
39626 {
39627 arg5 = wxString_in_helper(obj4);
39628 if (arg5 == NULL) SWIG_fail;
39629 temp5 = true;
39630 }
39631 }
39632 if (obj5) {
39633 ecode6 = SWIG_AsVal_int(obj5, &val6);
39634 if (!SWIG_IsOK(ecode6)) {
39635 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39636 }
39637 arg6 = static_cast< wxItemKind >(val6);
39638 }
39639 {
39640 PyThreadState* __tstate = wxPyBeginAllowThreads();
39641 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39642 wxPyEndAllowThreads(__tstate);
39643 if (PyErr_Occurred()) SWIG_fail;
39644 }
39645 {
39646 resultobj = wxPyMake_wxObject(result, (bool)0);
39647 }
39648 {
39649 if (temp4)
39650 delete arg4;
39651 }
39652 {
39653 if (temp5)
39654 delete arg5;
39655 }
39656 return resultobj;
39657 fail:
39658 {
39659 if (temp4)
39660 delete arg4;
39661 }
39662 {
39663 if (temp5)
39664 delete arg5;
39665 }
39666 return NULL;
39667 }
39668
39669
39670 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39671 PyObject *resultobj = 0;
39672 wxMenu *arg1 = (wxMenu *) 0 ;
39673 size_t arg2 ;
39674 wxMenuItem *result = 0 ;
39675 void *argp1 = 0 ;
39676 int res1 = 0 ;
39677 size_t val2 ;
39678 int ecode2 = 0 ;
39679 PyObject * obj0 = 0 ;
39680 PyObject * obj1 = 0 ;
39681 char * kwnames[] = {
39682 (char *) "self",(char *) "pos", NULL
39683 };
39684
39685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39687 if (!SWIG_IsOK(res1)) {
39688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39689 }
39690 arg1 = reinterpret_cast< wxMenu * >(argp1);
39691 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39692 if (!SWIG_IsOK(ecode2)) {
39693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39694 }
39695 arg2 = static_cast< size_t >(val2);
39696 {
39697 PyThreadState* __tstate = wxPyBeginAllowThreads();
39698 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39699 wxPyEndAllowThreads(__tstate);
39700 if (PyErr_Occurred()) SWIG_fail;
39701 }
39702 {
39703 resultobj = wxPyMake_wxObject(result, (bool)0);
39704 }
39705 return resultobj;
39706 fail:
39707 return NULL;
39708 }
39709
39710
39711 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39712 PyObject *resultobj = 0;
39713 wxMenu *arg1 = (wxMenu *) 0 ;
39714 size_t arg2 ;
39715 int arg3 ;
39716 wxString *arg4 = 0 ;
39717 wxString const &arg5_defvalue = wxPyEmptyString ;
39718 wxString *arg5 = (wxString *) &arg5_defvalue ;
39719 wxMenuItem *result = 0 ;
39720 void *argp1 = 0 ;
39721 int res1 = 0 ;
39722 size_t val2 ;
39723 int ecode2 = 0 ;
39724 int val3 ;
39725 int ecode3 = 0 ;
39726 bool temp4 = false ;
39727 bool temp5 = false ;
39728 PyObject * obj0 = 0 ;
39729 PyObject * obj1 = 0 ;
39730 PyObject * obj2 = 0 ;
39731 PyObject * obj3 = 0 ;
39732 PyObject * obj4 = 0 ;
39733 char * kwnames[] = {
39734 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39735 };
39736
39737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39739 if (!SWIG_IsOK(res1)) {
39740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39741 }
39742 arg1 = reinterpret_cast< wxMenu * >(argp1);
39743 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39744 if (!SWIG_IsOK(ecode2)) {
39745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39746 }
39747 arg2 = static_cast< size_t >(val2);
39748 ecode3 = SWIG_AsVal_int(obj2, &val3);
39749 if (!SWIG_IsOK(ecode3)) {
39750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39751 }
39752 arg3 = static_cast< int >(val3);
39753 {
39754 arg4 = wxString_in_helper(obj3);
39755 if (arg4 == NULL) SWIG_fail;
39756 temp4 = true;
39757 }
39758 if (obj4) {
39759 {
39760 arg5 = wxString_in_helper(obj4);
39761 if (arg5 == NULL) SWIG_fail;
39762 temp5 = true;
39763 }
39764 }
39765 {
39766 PyThreadState* __tstate = wxPyBeginAllowThreads();
39767 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39768 wxPyEndAllowThreads(__tstate);
39769 if (PyErr_Occurred()) SWIG_fail;
39770 }
39771 {
39772 resultobj = wxPyMake_wxObject(result, (bool)0);
39773 }
39774 {
39775 if (temp4)
39776 delete arg4;
39777 }
39778 {
39779 if (temp5)
39780 delete arg5;
39781 }
39782 return resultobj;
39783 fail:
39784 {
39785 if (temp4)
39786 delete arg4;
39787 }
39788 {
39789 if (temp5)
39790 delete arg5;
39791 }
39792 return NULL;
39793 }
39794
39795
39796 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39797 PyObject *resultobj = 0;
39798 wxMenu *arg1 = (wxMenu *) 0 ;
39799 size_t arg2 ;
39800 int arg3 ;
39801 wxString *arg4 = 0 ;
39802 wxString const &arg5_defvalue = wxPyEmptyString ;
39803 wxString *arg5 = (wxString *) &arg5_defvalue ;
39804 wxMenuItem *result = 0 ;
39805 void *argp1 = 0 ;
39806 int res1 = 0 ;
39807 size_t val2 ;
39808 int ecode2 = 0 ;
39809 int val3 ;
39810 int ecode3 = 0 ;
39811 bool temp4 = false ;
39812 bool temp5 = false ;
39813 PyObject * obj0 = 0 ;
39814 PyObject * obj1 = 0 ;
39815 PyObject * obj2 = 0 ;
39816 PyObject * obj3 = 0 ;
39817 PyObject * obj4 = 0 ;
39818 char * kwnames[] = {
39819 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39820 };
39821
39822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39824 if (!SWIG_IsOK(res1)) {
39825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39826 }
39827 arg1 = reinterpret_cast< wxMenu * >(argp1);
39828 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39829 if (!SWIG_IsOK(ecode2)) {
39830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39831 }
39832 arg2 = static_cast< size_t >(val2);
39833 ecode3 = SWIG_AsVal_int(obj2, &val3);
39834 if (!SWIG_IsOK(ecode3)) {
39835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39836 }
39837 arg3 = static_cast< int >(val3);
39838 {
39839 arg4 = wxString_in_helper(obj3);
39840 if (arg4 == NULL) SWIG_fail;
39841 temp4 = true;
39842 }
39843 if (obj4) {
39844 {
39845 arg5 = wxString_in_helper(obj4);
39846 if (arg5 == NULL) SWIG_fail;
39847 temp5 = true;
39848 }
39849 }
39850 {
39851 PyThreadState* __tstate = wxPyBeginAllowThreads();
39852 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39853 wxPyEndAllowThreads(__tstate);
39854 if (PyErr_Occurred()) SWIG_fail;
39855 }
39856 {
39857 resultobj = wxPyMake_wxObject(result, (bool)0);
39858 }
39859 {
39860 if (temp4)
39861 delete arg4;
39862 }
39863 {
39864 if (temp5)
39865 delete arg5;
39866 }
39867 return resultobj;
39868 fail:
39869 {
39870 if (temp4)
39871 delete arg4;
39872 }
39873 {
39874 if (temp5)
39875 delete arg5;
39876 }
39877 return NULL;
39878 }
39879
39880
39881 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39882 PyObject *resultobj = 0;
39883 wxMenu *arg1 = (wxMenu *) 0 ;
39884 size_t arg2 ;
39885 int arg3 ;
39886 wxString *arg4 = 0 ;
39887 wxMenu *arg5 = (wxMenu *) 0 ;
39888 wxString const &arg6_defvalue = wxPyEmptyString ;
39889 wxString *arg6 = (wxString *) &arg6_defvalue ;
39890 wxMenuItem *result = 0 ;
39891 void *argp1 = 0 ;
39892 int res1 = 0 ;
39893 size_t val2 ;
39894 int ecode2 = 0 ;
39895 int val3 ;
39896 int ecode3 = 0 ;
39897 bool temp4 = false ;
39898 void *argp5 = 0 ;
39899 int res5 = 0 ;
39900 bool temp6 = false ;
39901 PyObject * obj0 = 0 ;
39902 PyObject * obj1 = 0 ;
39903 PyObject * obj2 = 0 ;
39904 PyObject * obj3 = 0 ;
39905 PyObject * obj4 = 0 ;
39906 PyObject * obj5 = 0 ;
39907 char * kwnames[] = {
39908 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39909 };
39910
39911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39913 if (!SWIG_IsOK(res1)) {
39914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39915 }
39916 arg1 = reinterpret_cast< wxMenu * >(argp1);
39917 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39918 if (!SWIG_IsOK(ecode2)) {
39919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39920 }
39921 arg2 = static_cast< size_t >(val2);
39922 ecode3 = SWIG_AsVal_int(obj2, &val3);
39923 if (!SWIG_IsOK(ecode3)) {
39924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39925 }
39926 arg3 = static_cast< int >(val3);
39927 {
39928 arg4 = wxString_in_helper(obj3);
39929 if (arg4 == NULL) SWIG_fail;
39930 temp4 = true;
39931 }
39932 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39933 if (!SWIG_IsOK(res5)) {
39934 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39935 }
39936 arg5 = reinterpret_cast< wxMenu * >(argp5);
39937 if (obj5) {
39938 {
39939 arg6 = wxString_in_helper(obj5);
39940 if (arg6 == NULL) SWIG_fail;
39941 temp6 = true;
39942 }
39943 }
39944 {
39945 PyThreadState* __tstate = wxPyBeginAllowThreads();
39946 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39947 wxPyEndAllowThreads(__tstate);
39948 if (PyErr_Occurred()) SWIG_fail;
39949 }
39950 {
39951 resultobj = wxPyMake_wxObject(result, (bool)0);
39952 }
39953 {
39954 if (temp4)
39955 delete arg4;
39956 }
39957 {
39958 if (temp6)
39959 delete arg6;
39960 }
39961 return resultobj;
39962 fail:
39963 {
39964 if (temp4)
39965 delete arg4;
39966 }
39967 {
39968 if (temp6)
39969 delete arg6;
39970 }
39971 return NULL;
39972 }
39973
39974
39975 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39976 PyObject *resultobj = 0;
39977 wxMenu *arg1 = (wxMenu *) 0 ;
39978 int arg2 ;
39979 wxString const &arg3_defvalue = wxPyEmptyString ;
39980 wxString *arg3 = (wxString *) &arg3_defvalue ;
39981 wxString const &arg4_defvalue = wxPyEmptyString ;
39982 wxString *arg4 = (wxString *) &arg4_defvalue ;
39983 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39984 wxMenuItem *result = 0 ;
39985 void *argp1 = 0 ;
39986 int res1 = 0 ;
39987 int val2 ;
39988 int ecode2 = 0 ;
39989 bool temp3 = false ;
39990 bool temp4 = false ;
39991 int val5 ;
39992 int ecode5 = 0 ;
39993 PyObject * obj0 = 0 ;
39994 PyObject * obj1 = 0 ;
39995 PyObject * obj2 = 0 ;
39996 PyObject * obj3 = 0 ;
39997 PyObject * obj4 = 0 ;
39998 char * kwnames[] = {
39999 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40000 };
40001
40002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40004 if (!SWIG_IsOK(res1)) {
40005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40006 }
40007 arg1 = reinterpret_cast< wxMenu * >(argp1);
40008 ecode2 = SWIG_AsVal_int(obj1, &val2);
40009 if (!SWIG_IsOK(ecode2)) {
40010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40011 }
40012 arg2 = static_cast< int >(val2);
40013 if (obj2) {
40014 {
40015 arg3 = wxString_in_helper(obj2);
40016 if (arg3 == NULL) SWIG_fail;
40017 temp3 = true;
40018 }
40019 }
40020 if (obj3) {
40021 {
40022 arg4 = wxString_in_helper(obj3);
40023 if (arg4 == NULL) SWIG_fail;
40024 temp4 = true;
40025 }
40026 }
40027 if (obj4) {
40028 ecode5 = SWIG_AsVal_int(obj4, &val5);
40029 if (!SWIG_IsOK(ecode5)) {
40030 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40031 }
40032 arg5 = static_cast< wxItemKind >(val5);
40033 }
40034 {
40035 PyThreadState* __tstate = wxPyBeginAllowThreads();
40036 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40037 wxPyEndAllowThreads(__tstate);
40038 if (PyErr_Occurred()) SWIG_fail;
40039 }
40040 {
40041 resultobj = wxPyMake_wxObject(result, (bool)0);
40042 }
40043 {
40044 if (temp3)
40045 delete arg3;
40046 }
40047 {
40048 if (temp4)
40049 delete arg4;
40050 }
40051 return resultobj;
40052 fail:
40053 {
40054 if (temp3)
40055 delete arg3;
40056 }
40057 {
40058 if (temp4)
40059 delete arg4;
40060 }
40061 return NULL;
40062 }
40063
40064
40065 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40066 PyObject *resultobj = 0;
40067 wxMenu *arg1 = (wxMenu *) 0 ;
40068 wxMenuItem *result = 0 ;
40069 void *argp1 = 0 ;
40070 int res1 = 0 ;
40071 PyObject *swig_obj[1] ;
40072
40073 if (!args) SWIG_fail;
40074 swig_obj[0] = args;
40075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40076 if (!SWIG_IsOK(res1)) {
40077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40078 }
40079 arg1 = reinterpret_cast< wxMenu * >(argp1);
40080 {
40081 PyThreadState* __tstate = wxPyBeginAllowThreads();
40082 result = (wxMenuItem *)(arg1)->PrependSeparator();
40083 wxPyEndAllowThreads(__tstate);
40084 if (PyErr_Occurred()) SWIG_fail;
40085 }
40086 {
40087 resultobj = wxPyMake_wxObject(result, (bool)0);
40088 }
40089 return resultobj;
40090 fail:
40091 return NULL;
40092 }
40093
40094
40095 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40096 PyObject *resultobj = 0;
40097 wxMenu *arg1 = (wxMenu *) 0 ;
40098 int arg2 ;
40099 wxString *arg3 = 0 ;
40100 wxString const &arg4_defvalue = wxPyEmptyString ;
40101 wxString *arg4 = (wxString *) &arg4_defvalue ;
40102 wxMenuItem *result = 0 ;
40103 void *argp1 = 0 ;
40104 int res1 = 0 ;
40105 int val2 ;
40106 int ecode2 = 0 ;
40107 bool temp3 = false ;
40108 bool temp4 = false ;
40109 PyObject * obj0 = 0 ;
40110 PyObject * obj1 = 0 ;
40111 PyObject * obj2 = 0 ;
40112 PyObject * obj3 = 0 ;
40113 char * kwnames[] = {
40114 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40115 };
40116
40117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40119 if (!SWIG_IsOK(res1)) {
40120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40121 }
40122 arg1 = reinterpret_cast< wxMenu * >(argp1);
40123 ecode2 = SWIG_AsVal_int(obj1, &val2);
40124 if (!SWIG_IsOK(ecode2)) {
40125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40126 }
40127 arg2 = static_cast< int >(val2);
40128 {
40129 arg3 = wxString_in_helper(obj2);
40130 if (arg3 == NULL) SWIG_fail;
40131 temp3 = true;
40132 }
40133 if (obj3) {
40134 {
40135 arg4 = wxString_in_helper(obj3);
40136 if (arg4 == NULL) SWIG_fail;
40137 temp4 = true;
40138 }
40139 }
40140 {
40141 PyThreadState* __tstate = wxPyBeginAllowThreads();
40142 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40143 wxPyEndAllowThreads(__tstate);
40144 if (PyErr_Occurred()) SWIG_fail;
40145 }
40146 {
40147 resultobj = wxPyMake_wxObject(result, (bool)0);
40148 }
40149 {
40150 if (temp3)
40151 delete arg3;
40152 }
40153 {
40154 if (temp4)
40155 delete arg4;
40156 }
40157 return resultobj;
40158 fail:
40159 {
40160 if (temp3)
40161 delete arg3;
40162 }
40163 {
40164 if (temp4)
40165 delete arg4;
40166 }
40167 return NULL;
40168 }
40169
40170
40171 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40172 PyObject *resultobj = 0;
40173 wxMenu *arg1 = (wxMenu *) 0 ;
40174 int arg2 ;
40175 wxString *arg3 = 0 ;
40176 wxString const &arg4_defvalue = wxPyEmptyString ;
40177 wxString *arg4 = (wxString *) &arg4_defvalue ;
40178 wxMenuItem *result = 0 ;
40179 void *argp1 = 0 ;
40180 int res1 = 0 ;
40181 int val2 ;
40182 int ecode2 = 0 ;
40183 bool temp3 = false ;
40184 bool temp4 = false ;
40185 PyObject * obj0 = 0 ;
40186 PyObject * obj1 = 0 ;
40187 PyObject * obj2 = 0 ;
40188 PyObject * obj3 = 0 ;
40189 char * kwnames[] = {
40190 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40191 };
40192
40193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40195 if (!SWIG_IsOK(res1)) {
40196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40197 }
40198 arg1 = reinterpret_cast< wxMenu * >(argp1);
40199 ecode2 = SWIG_AsVal_int(obj1, &val2);
40200 if (!SWIG_IsOK(ecode2)) {
40201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40202 }
40203 arg2 = static_cast< int >(val2);
40204 {
40205 arg3 = wxString_in_helper(obj2);
40206 if (arg3 == NULL) SWIG_fail;
40207 temp3 = true;
40208 }
40209 if (obj3) {
40210 {
40211 arg4 = wxString_in_helper(obj3);
40212 if (arg4 == NULL) SWIG_fail;
40213 temp4 = true;
40214 }
40215 }
40216 {
40217 PyThreadState* __tstate = wxPyBeginAllowThreads();
40218 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40219 wxPyEndAllowThreads(__tstate);
40220 if (PyErr_Occurred()) SWIG_fail;
40221 }
40222 {
40223 resultobj = wxPyMake_wxObject(result, (bool)0);
40224 }
40225 {
40226 if (temp3)
40227 delete arg3;
40228 }
40229 {
40230 if (temp4)
40231 delete arg4;
40232 }
40233 return resultobj;
40234 fail:
40235 {
40236 if (temp3)
40237 delete arg3;
40238 }
40239 {
40240 if (temp4)
40241 delete arg4;
40242 }
40243 return NULL;
40244 }
40245
40246
40247 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40248 PyObject *resultobj = 0;
40249 wxMenu *arg1 = (wxMenu *) 0 ;
40250 int arg2 ;
40251 wxString *arg3 = 0 ;
40252 wxMenu *arg4 = (wxMenu *) 0 ;
40253 wxString const &arg5_defvalue = wxPyEmptyString ;
40254 wxString *arg5 = (wxString *) &arg5_defvalue ;
40255 wxMenuItem *result = 0 ;
40256 void *argp1 = 0 ;
40257 int res1 = 0 ;
40258 int val2 ;
40259 int ecode2 = 0 ;
40260 bool temp3 = false ;
40261 void *argp4 = 0 ;
40262 int res4 = 0 ;
40263 bool temp5 = false ;
40264 PyObject * obj0 = 0 ;
40265 PyObject * obj1 = 0 ;
40266 PyObject * obj2 = 0 ;
40267 PyObject * obj3 = 0 ;
40268 PyObject * obj4 = 0 ;
40269 char * kwnames[] = {
40270 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40271 };
40272
40273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40275 if (!SWIG_IsOK(res1)) {
40276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40277 }
40278 arg1 = reinterpret_cast< wxMenu * >(argp1);
40279 ecode2 = SWIG_AsVal_int(obj1, &val2);
40280 if (!SWIG_IsOK(ecode2)) {
40281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40282 }
40283 arg2 = static_cast< int >(val2);
40284 {
40285 arg3 = wxString_in_helper(obj2);
40286 if (arg3 == NULL) SWIG_fail;
40287 temp3 = true;
40288 }
40289 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40290 if (!SWIG_IsOK(res4)) {
40291 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40292 }
40293 arg4 = reinterpret_cast< wxMenu * >(argp4);
40294 if (obj4) {
40295 {
40296 arg5 = wxString_in_helper(obj4);
40297 if (arg5 == NULL) SWIG_fail;
40298 temp5 = true;
40299 }
40300 }
40301 {
40302 PyThreadState* __tstate = wxPyBeginAllowThreads();
40303 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40304 wxPyEndAllowThreads(__tstate);
40305 if (PyErr_Occurred()) SWIG_fail;
40306 }
40307 {
40308 resultobj = wxPyMake_wxObject(result, (bool)0);
40309 }
40310 {
40311 if (temp3)
40312 delete arg3;
40313 }
40314 {
40315 if (temp5)
40316 delete arg5;
40317 }
40318 return resultobj;
40319 fail:
40320 {
40321 if (temp3)
40322 delete arg3;
40323 }
40324 {
40325 if (temp5)
40326 delete arg5;
40327 }
40328 return NULL;
40329 }
40330
40331
40332 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40333 PyObject *resultobj = 0;
40334 wxMenu *arg1 = (wxMenu *) 0 ;
40335 int arg2 ;
40336 wxMenuItem *result = 0 ;
40337 void *argp1 = 0 ;
40338 int res1 = 0 ;
40339 int val2 ;
40340 int ecode2 = 0 ;
40341 PyObject * obj0 = 0 ;
40342 PyObject * obj1 = 0 ;
40343 char * kwnames[] = {
40344 (char *) "self",(char *) "id", NULL
40345 };
40346
40347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40349 if (!SWIG_IsOK(res1)) {
40350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40351 }
40352 arg1 = reinterpret_cast< wxMenu * >(argp1);
40353 ecode2 = SWIG_AsVal_int(obj1, &val2);
40354 if (!SWIG_IsOK(ecode2)) {
40355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40356 }
40357 arg2 = static_cast< int >(val2);
40358 {
40359 PyThreadState* __tstate = wxPyBeginAllowThreads();
40360 result = (wxMenuItem *)(arg1)->Remove(arg2);
40361 wxPyEndAllowThreads(__tstate);
40362 if (PyErr_Occurred()) SWIG_fail;
40363 }
40364 {
40365 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40366 }
40367 return resultobj;
40368 fail:
40369 return NULL;
40370 }
40371
40372
40373 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40374 PyObject *resultobj = 0;
40375 wxMenu *arg1 = (wxMenu *) 0 ;
40376 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40377 wxMenuItem *result = 0 ;
40378 void *argp1 = 0 ;
40379 int res1 = 0 ;
40380 void *argp2 = 0 ;
40381 int res2 = 0 ;
40382 PyObject * obj0 = 0 ;
40383 PyObject * obj1 = 0 ;
40384 char * kwnames[] = {
40385 (char *) "self",(char *) "item", NULL
40386 };
40387
40388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40390 if (!SWIG_IsOK(res1)) {
40391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40392 }
40393 arg1 = reinterpret_cast< wxMenu * >(argp1);
40394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40395 if (!SWIG_IsOK(res2)) {
40396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40397 }
40398 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40399 {
40400 PyThreadState* __tstate = wxPyBeginAllowThreads();
40401 result = (wxMenuItem *)(arg1)->Remove(arg2);
40402 wxPyEndAllowThreads(__tstate);
40403 if (PyErr_Occurred()) SWIG_fail;
40404 }
40405 {
40406 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40407 }
40408 return resultobj;
40409 fail:
40410 return NULL;
40411 }
40412
40413
40414 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40415 PyObject *resultobj = 0;
40416 wxMenu *arg1 = (wxMenu *) 0 ;
40417 int arg2 ;
40418 bool result;
40419 void *argp1 = 0 ;
40420 int res1 = 0 ;
40421 int val2 ;
40422 int ecode2 = 0 ;
40423 PyObject * obj0 = 0 ;
40424 PyObject * obj1 = 0 ;
40425 char * kwnames[] = {
40426 (char *) "self",(char *) "id", NULL
40427 };
40428
40429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40431 if (!SWIG_IsOK(res1)) {
40432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40433 }
40434 arg1 = reinterpret_cast< wxMenu * >(argp1);
40435 ecode2 = SWIG_AsVal_int(obj1, &val2);
40436 if (!SWIG_IsOK(ecode2)) {
40437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40438 }
40439 arg2 = static_cast< int >(val2);
40440 {
40441 PyThreadState* __tstate = wxPyBeginAllowThreads();
40442 result = (bool)(arg1)->Delete(arg2);
40443 wxPyEndAllowThreads(__tstate);
40444 if (PyErr_Occurred()) SWIG_fail;
40445 }
40446 {
40447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40448 }
40449 return resultobj;
40450 fail:
40451 return NULL;
40452 }
40453
40454
40455 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40456 PyObject *resultobj = 0;
40457 wxMenu *arg1 = (wxMenu *) 0 ;
40458 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40459 bool result;
40460 void *argp1 = 0 ;
40461 int res1 = 0 ;
40462 void *argp2 = 0 ;
40463 int res2 = 0 ;
40464 PyObject * obj0 = 0 ;
40465 PyObject * obj1 = 0 ;
40466 char * kwnames[] = {
40467 (char *) "self",(char *) "item", NULL
40468 };
40469
40470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40472 if (!SWIG_IsOK(res1)) {
40473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40474 }
40475 arg1 = reinterpret_cast< wxMenu * >(argp1);
40476 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40477 if (!SWIG_IsOK(res2)) {
40478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40479 }
40480 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40481 {
40482 PyThreadState* __tstate = wxPyBeginAllowThreads();
40483 result = (bool)(arg1)->Delete(arg2);
40484 wxPyEndAllowThreads(__tstate);
40485 if (PyErr_Occurred()) SWIG_fail;
40486 }
40487 {
40488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40489 }
40490 return resultobj;
40491 fail:
40492 return NULL;
40493 }
40494
40495
40496 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40497 PyObject *resultobj = 0;
40498 wxMenu *arg1 = (wxMenu *) 0 ;
40499 void *argp1 = 0 ;
40500 int res1 = 0 ;
40501 PyObject *swig_obj[1] ;
40502
40503 if (!args) SWIG_fail;
40504 swig_obj[0] = args;
40505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40506 if (!SWIG_IsOK(res1)) {
40507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40508 }
40509 arg1 = reinterpret_cast< wxMenu * >(argp1);
40510 {
40511 PyThreadState* __tstate = wxPyBeginAllowThreads();
40512 wxMenu_Destroy(arg1);
40513 wxPyEndAllowThreads(__tstate);
40514 if (PyErr_Occurred()) SWIG_fail;
40515 }
40516 resultobj = SWIG_Py_Void();
40517 return resultobj;
40518 fail:
40519 return NULL;
40520 }
40521
40522
40523 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40524 PyObject *resultobj = 0;
40525 wxMenu *arg1 = (wxMenu *) 0 ;
40526 int arg2 ;
40527 bool result;
40528 void *argp1 = 0 ;
40529 int res1 = 0 ;
40530 int val2 ;
40531 int ecode2 = 0 ;
40532 PyObject * obj0 = 0 ;
40533 PyObject * obj1 = 0 ;
40534 char * kwnames[] = {
40535 (char *) "self",(char *) "id", NULL
40536 };
40537
40538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40540 if (!SWIG_IsOK(res1)) {
40541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40542 }
40543 arg1 = reinterpret_cast< wxMenu * >(argp1);
40544 ecode2 = SWIG_AsVal_int(obj1, &val2);
40545 if (!SWIG_IsOK(ecode2)) {
40546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40547 }
40548 arg2 = static_cast< int >(val2);
40549 {
40550 PyThreadState* __tstate = wxPyBeginAllowThreads();
40551 result = (bool)(arg1)->Destroy(arg2);
40552 wxPyEndAllowThreads(__tstate);
40553 if (PyErr_Occurred()) SWIG_fail;
40554 }
40555 {
40556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40557 }
40558 return resultobj;
40559 fail:
40560 return NULL;
40561 }
40562
40563
40564 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40565 PyObject *resultobj = 0;
40566 wxMenu *arg1 = (wxMenu *) 0 ;
40567 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40568 bool result;
40569 void *argp1 = 0 ;
40570 int res1 = 0 ;
40571 void *argp2 = 0 ;
40572 int res2 = 0 ;
40573 PyObject * obj0 = 0 ;
40574 PyObject * obj1 = 0 ;
40575 char * kwnames[] = {
40576 (char *) "self",(char *) "item", NULL
40577 };
40578
40579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40581 if (!SWIG_IsOK(res1)) {
40582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40583 }
40584 arg1 = reinterpret_cast< wxMenu * >(argp1);
40585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40586 if (!SWIG_IsOK(res2)) {
40587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40588 }
40589 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40590 {
40591 PyThreadState* __tstate = wxPyBeginAllowThreads();
40592 result = (bool)(arg1)->Destroy(arg2);
40593 wxPyEndAllowThreads(__tstate);
40594 if (PyErr_Occurred()) SWIG_fail;
40595 }
40596 {
40597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40598 }
40599 return resultobj;
40600 fail:
40601 return NULL;
40602 }
40603
40604
40605 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40606 PyObject *resultobj = 0;
40607 wxMenu *arg1 = (wxMenu *) 0 ;
40608 size_t result;
40609 void *argp1 = 0 ;
40610 int res1 = 0 ;
40611 PyObject *swig_obj[1] ;
40612
40613 if (!args) SWIG_fail;
40614 swig_obj[0] = args;
40615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40616 if (!SWIG_IsOK(res1)) {
40617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40618 }
40619 arg1 = reinterpret_cast< wxMenu * >(argp1);
40620 {
40621 PyThreadState* __tstate = wxPyBeginAllowThreads();
40622 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40623 wxPyEndAllowThreads(__tstate);
40624 if (PyErr_Occurred()) SWIG_fail;
40625 }
40626 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40627 return resultobj;
40628 fail:
40629 return NULL;
40630 }
40631
40632
40633 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40634 PyObject *resultobj = 0;
40635 wxMenu *arg1 = (wxMenu *) 0 ;
40636 PyObject *result = 0 ;
40637 void *argp1 = 0 ;
40638 int res1 = 0 ;
40639 PyObject *swig_obj[1] ;
40640
40641 if (!args) SWIG_fail;
40642 swig_obj[0] = args;
40643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40644 if (!SWIG_IsOK(res1)) {
40645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40646 }
40647 arg1 = reinterpret_cast< wxMenu * >(argp1);
40648 {
40649 PyThreadState* __tstate = wxPyBeginAllowThreads();
40650 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40651 wxPyEndAllowThreads(__tstate);
40652 if (PyErr_Occurred()) SWIG_fail;
40653 }
40654 resultobj = result;
40655 return resultobj;
40656 fail:
40657 return NULL;
40658 }
40659
40660
40661 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40662 PyObject *resultobj = 0;
40663 wxMenu *arg1 = (wxMenu *) 0 ;
40664 wxString *arg2 = 0 ;
40665 int result;
40666 void *argp1 = 0 ;
40667 int res1 = 0 ;
40668 bool temp2 = false ;
40669 PyObject * obj0 = 0 ;
40670 PyObject * obj1 = 0 ;
40671 char * kwnames[] = {
40672 (char *) "self",(char *) "item", NULL
40673 };
40674
40675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40677 if (!SWIG_IsOK(res1)) {
40678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40679 }
40680 arg1 = reinterpret_cast< wxMenu * >(argp1);
40681 {
40682 arg2 = wxString_in_helper(obj1);
40683 if (arg2 == NULL) SWIG_fail;
40684 temp2 = true;
40685 }
40686 {
40687 PyThreadState* __tstate = wxPyBeginAllowThreads();
40688 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40689 wxPyEndAllowThreads(__tstate);
40690 if (PyErr_Occurred()) SWIG_fail;
40691 }
40692 resultobj = SWIG_From_int(static_cast< int >(result));
40693 {
40694 if (temp2)
40695 delete arg2;
40696 }
40697 return resultobj;
40698 fail:
40699 {
40700 if (temp2)
40701 delete arg2;
40702 }
40703 return NULL;
40704 }
40705
40706
40707 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40708 PyObject *resultobj = 0;
40709 wxMenu *arg1 = (wxMenu *) 0 ;
40710 int arg2 ;
40711 wxMenuItem *result = 0 ;
40712 void *argp1 = 0 ;
40713 int res1 = 0 ;
40714 int val2 ;
40715 int ecode2 = 0 ;
40716 PyObject * obj0 = 0 ;
40717 PyObject * obj1 = 0 ;
40718 char * kwnames[] = {
40719 (char *) "self",(char *) "id", NULL
40720 };
40721
40722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40724 if (!SWIG_IsOK(res1)) {
40725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40726 }
40727 arg1 = reinterpret_cast< wxMenu * >(argp1);
40728 ecode2 = SWIG_AsVal_int(obj1, &val2);
40729 if (!SWIG_IsOK(ecode2)) {
40730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40731 }
40732 arg2 = static_cast< int >(val2);
40733 {
40734 PyThreadState* __tstate = wxPyBeginAllowThreads();
40735 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40736 wxPyEndAllowThreads(__tstate);
40737 if (PyErr_Occurred()) SWIG_fail;
40738 }
40739 {
40740 resultobj = wxPyMake_wxObject(result, (bool)0);
40741 }
40742 return resultobj;
40743 fail:
40744 return NULL;
40745 }
40746
40747
40748 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40749 PyObject *resultobj = 0;
40750 wxMenu *arg1 = (wxMenu *) 0 ;
40751 size_t arg2 ;
40752 wxMenuItem *result = 0 ;
40753 void *argp1 = 0 ;
40754 int res1 = 0 ;
40755 size_t val2 ;
40756 int ecode2 = 0 ;
40757 PyObject * obj0 = 0 ;
40758 PyObject * obj1 = 0 ;
40759 char * kwnames[] = {
40760 (char *) "self",(char *) "position", NULL
40761 };
40762
40763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40765 if (!SWIG_IsOK(res1)) {
40766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40767 }
40768 arg1 = reinterpret_cast< wxMenu * >(argp1);
40769 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40770 if (!SWIG_IsOK(ecode2)) {
40771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40772 }
40773 arg2 = static_cast< size_t >(val2);
40774 {
40775 PyThreadState* __tstate = wxPyBeginAllowThreads();
40776 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40777 wxPyEndAllowThreads(__tstate);
40778 if (PyErr_Occurred()) SWIG_fail;
40779 }
40780 {
40781 resultobj = wxPyMake_wxObject(result, (bool)0);
40782 }
40783 return resultobj;
40784 fail:
40785 return NULL;
40786 }
40787
40788
40789 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40790 PyObject *resultobj = 0;
40791 wxMenu *arg1 = (wxMenu *) 0 ;
40792 int arg2 ;
40793 bool arg3 ;
40794 void *argp1 = 0 ;
40795 int res1 = 0 ;
40796 int val2 ;
40797 int ecode2 = 0 ;
40798 bool val3 ;
40799 int ecode3 = 0 ;
40800 PyObject * obj0 = 0 ;
40801 PyObject * obj1 = 0 ;
40802 PyObject * obj2 = 0 ;
40803 char * kwnames[] = {
40804 (char *) "self",(char *) "id",(char *) "enable", NULL
40805 };
40806
40807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40809 if (!SWIG_IsOK(res1)) {
40810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40811 }
40812 arg1 = reinterpret_cast< wxMenu * >(argp1);
40813 ecode2 = SWIG_AsVal_int(obj1, &val2);
40814 if (!SWIG_IsOK(ecode2)) {
40815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40816 }
40817 arg2 = static_cast< int >(val2);
40818 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40819 if (!SWIG_IsOK(ecode3)) {
40820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40821 }
40822 arg3 = static_cast< bool >(val3);
40823 {
40824 PyThreadState* __tstate = wxPyBeginAllowThreads();
40825 (arg1)->Enable(arg2,arg3);
40826 wxPyEndAllowThreads(__tstate);
40827 if (PyErr_Occurred()) SWIG_fail;
40828 }
40829 resultobj = SWIG_Py_Void();
40830 return resultobj;
40831 fail:
40832 return NULL;
40833 }
40834
40835
40836 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40837 PyObject *resultobj = 0;
40838 wxMenu *arg1 = (wxMenu *) 0 ;
40839 int arg2 ;
40840 bool result;
40841 void *argp1 = 0 ;
40842 int res1 = 0 ;
40843 int val2 ;
40844 int ecode2 = 0 ;
40845 PyObject * obj0 = 0 ;
40846 PyObject * obj1 = 0 ;
40847 char * kwnames[] = {
40848 (char *) "self",(char *) "id", NULL
40849 };
40850
40851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40853 if (!SWIG_IsOK(res1)) {
40854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40855 }
40856 arg1 = reinterpret_cast< wxMenu * >(argp1);
40857 ecode2 = SWIG_AsVal_int(obj1, &val2);
40858 if (!SWIG_IsOK(ecode2)) {
40859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40860 }
40861 arg2 = static_cast< int >(val2);
40862 {
40863 PyThreadState* __tstate = wxPyBeginAllowThreads();
40864 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40865 wxPyEndAllowThreads(__tstate);
40866 if (PyErr_Occurred()) SWIG_fail;
40867 }
40868 {
40869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40870 }
40871 return resultobj;
40872 fail:
40873 return NULL;
40874 }
40875
40876
40877 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40878 PyObject *resultobj = 0;
40879 wxMenu *arg1 = (wxMenu *) 0 ;
40880 int arg2 ;
40881 bool arg3 ;
40882 void *argp1 = 0 ;
40883 int res1 = 0 ;
40884 int val2 ;
40885 int ecode2 = 0 ;
40886 bool val3 ;
40887 int ecode3 = 0 ;
40888 PyObject * obj0 = 0 ;
40889 PyObject * obj1 = 0 ;
40890 PyObject * obj2 = 0 ;
40891 char * kwnames[] = {
40892 (char *) "self",(char *) "id",(char *) "check", NULL
40893 };
40894
40895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40897 if (!SWIG_IsOK(res1)) {
40898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40899 }
40900 arg1 = reinterpret_cast< wxMenu * >(argp1);
40901 ecode2 = SWIG_AsVal_int(obj1, &val2);
40902 if (!SWIG_IsOK(ecode2)) {
40903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40904 }
40905 arg2 = static_cast< int >(val2);
40906 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40907 if (!SWIG_IsOK(ecode3)) {
40908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40909 }
40910 arg3 = static_cast< bool >(val3);
40911 {
40912 PyThreadState* __tstate = wxPyBeginAllowThreads();
40913 (arg1)->Check(arg2,arg3);
40914 wxPyEndAllowThreads(__tstate);
40915 if (PyErr_Occurred()) SWIG_fail;
40916 }
40917 resultobj = SWIG_Py_Void();
40918 return resultobj;
40919 fail:
40920 return NULL;
40921 }
40922
40923
40924 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40925 PyObject *resultobj = 0;
40926 wxMenu *arg1 = (wxMenu *) 0 ;
40927 int arg2 ;
40928 bool result;
40929 void *argp1 = 0 ;
40930 int res1 = 0 ;
40931 int val2 ;
40932 int ecode2 = 0 ;
40933 PyObject * obj0 = 0 ;
40934 PyObject * obj1 = 0 ;
40935 char * kwnames[] = {
40936 (char *) "self",(char *) "id", NULL
40937 };
40938
40939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40941 if (!SWIG_IsOK(res1)) {
40942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40943 }
40944 arg1 = reinterpret_cast< wxMenu * >(argp1);
40945 ecode2 = SWIG_AsVal_int(obj1, &val2);
40946 if (!SWIG_IsOK(ecode2)) {
40947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40948 }
40949 arg2 = static_cast< int >(val2);
40950 {
40951 PyThreadState* __tstate = wxPyBeginAllowThreads();
40952 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40953 wxPyEndAllowThreads(__tstate);
40954 if (PyErr_Occurred()) SWIG_fail;
40955 }
40956 {
40957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40958 }
40959 return resultobj;
40960 fail:
40961 return NULL;
40962 }
40963
40964
40965 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40966 PyObject *resultobj = 0;
40967 wxMenu *arg1 = (wxMenu *) 0 ;
40968 int arg2 ;
40969 wxString *arg3 = 0 ;
40970 void *argp1 = 0 ;
40971 int res1 = 0 ;
40972 int val2 ;
40973 int ecode2 = 0 ;
40974 bool temp3 = false ;
40975 PyObject * obj0 = 0 ;
40976 PyObject * obj1 = 0 ;
40977 PyObject * obj2 = 0 ;
40978 char * kwnames[] = {
40979 (char *) "self",(char *) "id",(char *) "label", NULL
40980 };
40981
40982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40984 if (!SWIG_IsOK(res1)) {
40985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40986 }
40987 arg1 = reinterpret_cast< wxMenu * >(argp1);
40988 ecode2 = SWIG_AsVal_int(obj1, &val2);
40989 if (!SWIG_IsOK(ecode2)) {
40990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40991 }
40992 arg2 = static_cast< int >(val2);
40993 {
40994 arg3 = wxString_in_helper(obj2);
40995 if (arg3 == NULL) SWIG_fail;
40996 temp3 = true;
40997 }
40998 {
40999 PyThreadState* __tstate = wxPyBeginAllowThreads();
41000 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41001 wxPyEndAllowThreads(__tstate);
41002 if (PyErr_Occurred()) SWIG_fail;
41003 }
41004 resultobj = SWIG_Py_Void();
41005 {
41006 if (temp3)
41007 delete arg3;
41008 }
41009 return resultobj;
41010 fail:
41011 {
41012 if (temp3)
41013 delete arg3;
41014 }
41015 return NULL;
41016 }
41017
41018
41019 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj = 0;
41021 wxMenu *arg1 = (wxMenu *) 0 ;
41022 int arg2 ;
41023 wxString result;
41024 void *argp1 = 0 ;
41025 int res1 = 0 ;
41026 int val2 ;
41027 int ecode2 = 0 ;
41028 PyObject * obj0 = 0 ;
41029 PyObject * obj1 = 0 ;
41030 char * kwnames[] = {
41031 (char *) "self",(char *) "id", NULL
41032 };
41033
41034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41036 if (!SWIG_IsOK(res1)) {
41037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41038 }
41039 arg1 = reinterpret_cast< wxMenu * >(argp1);
41040 ecode2 = SWIG_AsVal_int(obj1, &val2);
41041 if (!SWIG_IsOK(ecode2)) {
41042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41043 }
41044 arg2 = static_cast< int >(val2);
41045 {
41046 PyThreadState* __tstate = wxPyBeginAllowThreads();
41047 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41048 wxPyEndAllowThreads(__tstate);
41049 if (PyErr_Occurred()) SWIG_fail;
41050 }
41051 {
41052 #if wxUSE_UNICODE
41053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41054 #else
41055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41056 #endif
41057 }
41058 return resultobj;
41059 fail:
41060 return NULL;
41061 }
41062
41063
41064 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41065 PyObject *resultobj = 0;
41066 wxMenu *arg1 = (wxMenu *) 0 ;
41067 int arg2 ;
41068 wxString *arg3 = 0 ;
41069 void *argp1 = 0 ;
41070 int res1 = 0 ;
41071 int val2 ;
41072 int ecode2 = 0 ;
41073 bool temp3 = false ;
41074 PyObject * obj0 = 0 ;
41075 PyObject * obj1 = 0 ;
41076 PyObject * obj2 = 0 ;
41077 char * kwnames[] = {
41078 (char *) "self",(char *) "id",(char *) "helpString", NULL
41079 };
41080
41081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41083 if (!SWIG_IsOK(res1)) {
41084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41085 }
41086 arg1 = reinterpret_cast< wxMenu * >(argp1);
41087 ecode2 = SWIG_AsVal_int(obj1, &val2);
41088 if (!SWIG_IsOK(ecode2)) {
41089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41090 }
41091 arg2 = static_cast< int >(val2);
41092 {
41093 arg3 = wxString_in_helper(obj2);
41094 if (arg3 == NULL) SWIG_fail;
41095 temp3 = true;
41096 }
41097 {
41098 PyThreadState* __tstate = wxPyBeginAllowThreads();
41099 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41100 wxPyEndAllowThreads(__tstate);
41101 if (PyErr_Occurred()) SWIG_fail;
41102 }
41103 resultobj = SWIG_Py_Void();
41104 {
41105 if (temp3)
41106 delete arg3;
41107 }
41108 return resultobj;
41109 fail:
41110 {
41111 if (temp3)
41112 delete arg3;
41113 }
41114 return NULL;
41115 }
41116
41117
41118 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41119 PyObject *resultobj = 0;
41120 wxMenu *arg1 = (wxMenu *) 0 ;
41121 int arg2 ;
41122 wxString result;
41123 void *argp1 = 0 ;
41124 int res1 = 0 ;
41125 int val2 ;
41126 int ecode2 = 0 ;
41127 PyObject * obj0 = 0 ;
41128 PyObject * obj1 = 0 ;
41129 char * kwnames[] = {
41130 (char *) "self",(char *) "id", NULL
41131 };
41132
41133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41135 if (!SWIG_IsOK(res1)) {
41136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41137 }
41138 arg1 = reinterpret_cast< wxMenu * >(argp1);
41139 ecode2 = SWIG_AsVal_int(obj1, &val2);
41140 if (!SWIG_IsOK(ecode2)) {
41141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41142 }
41143 arg2 = static_cast< int >(val2);
41144 {
41145 PyThreadState* __tstate = wxPyBeginAllowThreads();
41146 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41147 wxPyEndAllowThreads(__tstate);
41148 if (PyErr_Occurred()) SWIG_fail;
41149 }
41150 {
41151 #if wxUSE_UNICODE
41152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41153 #else
41154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41155 #endif
41156 }
41157 return resultobj;
41158 fail:
41159 return NULL;
41160 }
41161
41162
41163 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41164 PyObject *resultobj = 0;
41165 wxMenu *arg1 = (wxMenu *) 0 ;
41166 wxString *arg2 = 0 ;
41167 void *argp1 = 0 ;
41168 int res1 = 0 ;
41169 bool temp2 = false ;
41170 PyObject * obj0 = 0 ;
41171 PyObject * obj1 = 0 ;
41172 char * kwnames[] = {
41173 (char *) "self",(char *) "title", NULL
41174 };
41175
41176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41178 if (!SWIG_IsOK(res1)) {
41179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41180 }
41181 arg1 = reinterpret_cast< wxMenu * >(argp1);
41182 {
41183 arg2 = wxString_in_helper(obj1);
41184 if (arg2 == NULL) SWIG_fail;
41185 temp2 = true;
41186 }
41187 {
41188 PyThreadState* __tstate = wxPyBeginAllowThreads();
41189 (arg1)->SetTitle((wxString const &)*arg2);
41190 wxPyEndAllowThreads(__tstate);
41191 if (PyErr_Occurred()) SWIG_fail;
41192 }
41193 resultobj = SWIG_Py_Void();
41194 {
41195 if (temp2)
41196 delete arg2;
41197 }
41198 return resultobj;
41199 fail:
41200 {
41201 if (temp2)
41202 delete arg2;
41203 }
41204 return NULL;
41205 }
41206
41207
41208 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41209 PyObject *resultobj = 0;
41210 wxMenu *arg1 = (wxMenu *) 0 ;
41211 wxString result;
41212 void *argp1 = 0 ;
41213 int res1 = 0 ;
41214 PyObject *swig_obj[1] ;
41215
41216 if (!args) SWIG_fail;
41217 swig_obj[0] = args;
41218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41219 if (!SWIG_IsOK(res1)) {
41220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41221 }
41222 arg1 = reinterpret_cast< wxMenu * >(argp1);
41223 {
41224 PyThreadState* __tstate = wxPyBeginAllowThreads();
41225 result = ((wxMenu const *)arg1)->GetTitle();
41226 wxPyEndAllowThreads(__tstate);
41227 if (PyErr_Occurred()) SWIG_fail;
41228 }
41229 {
41230 #if wxUSE_UNICODE
41231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41232 #else
41233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41234 #endif
41235 }
41236 return resultobj;
41237 fail:
41238 return NULL;
41239 }
41240
41241
41242 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41243 PyObject *resultobj = 0;
41244 wxMenu *arg1 = (wxMenu *) 0 ;
41245 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41246 void *argp1 = 0 ;
41247 int res1 = 0 ;
41248 void *argp2 = 0 ;
41249 int res2 = 0 ;
41250 PyObject * obj0 = 0 ;
41251 PyObject * obj1 = 0 ;
41252 char * kwnames[] = {
41253 (char *) "self",(char *) "handler", NULL
41254 };
41255
41256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41258 if (!SWIG_IsOK(res1)) {
41259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41260 }
41261 arg1 = reinterpret_cast< wxMenu * >(argp1);
41262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41263 if (!SWIG_IsOK(res2)) {
41264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41265 }
41266 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41267 {
41268 PyThreadState* __tstate = wxPyBeginAllowThreads();
41269 (arg1)->SetEventHandler(arg2);
41270 wxPyEndAllowThreads(__tstate);
41271 if (PyErr_Occurred()) SWIG_fail;
41272 }
41273 resultobj = SWIG_Py_Void();
41274 return resultobj;
41275 fail:
41276 return NULL;
41277 }
41278
41279
41280 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41281 PyObject *resultobj = 0;
41282 wxMenu *arg1 = (wxMenu *) 0 ;
41283 wxEvtHandler *result = 0 ;
41284 void *argp1 = 0 ;
41285 int res1 = 0 ;
41286 PyObject *swig_obj[1] ;
41287
41288 if (!args) SWIG_fail;
41289 swig_obj[0] = args;
41290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41291 if (!SWIG_IsOK(res1)) {
41292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41293 }
41294 arg1 = reinterpret_cast< wxMenu * >(argp1);
41295 {
41296 PyThreadState* __tstate = wxPyBeginAllowThreads();
41297 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41298 wxPyEndAllowThreads(__tstate);
41299 if (PyErr_Occurred()) SWIG_fail;
41300 }
41301 {
41302 resultobj = wxPyMake_wxObject(result, 0);
41303 }
41304 return resultobj;
41305 fail:
41306 return NULL;
41307 }
41308
41309
41310 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41311 PyObject *resultobj = 0;
41312 wxMenu *arg1 = (wxMenu *) 0 ;
41313 wxWindow *arg2 = (wxWindow *) 0 ;
41314 void *argp1 = 0 ;
41315 int res1 = 0 ;
41316 void *argp2 = 0 ;
41317 int res2 = 0 ;
41318 PyObject * obj0 = 0 ;
41319 PyObject * obj1 = 0 ;
41320 char * kwnames[] = {
41321 (char *) "self",(char *) "win", NULL
41322 };
41323
41324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41326 if (!SWIG_IsOK(res1)) {
41327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41328 }
41329 arg1 = reinterpret_cast< wxMenu * >(argp1);
41330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41331 if (!SWIG_IsOK(res2)) {
41332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41333 }
41334 arg2 = reinterpret_cast< wxWindow * >(argp2);
41335 {
41336 PyThreadState* __tstate = wxPyBeginAllowThreads();
41337 (arg1)->SetInvokingWindow(arg2);
41338 wxPyEndAllowThreads(__tstate);
41339 if (PyErr_Occurred()) SWIG_fail;
41340 }
41341 resultobj = SWIG_Py_Void();
41342 return resultobj;
41343 fail:
41344 return NULL;
41345 }
41346
41347
41348 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41349 PyObject *resultobj = 0;
41350 wxMenu *arg1 = (wxMenu *) 0 ;
41351 wxWindow *result = 0 ;
41352 void *argp1 = 0 ;
41353 int res1 = 0 ;
41354 PyObject *swig_obj[1] ;
41355
41356 if (!args) SWIG_fail;
41357 swig_obj[0] = args;
41358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41359 if (!SWIG_IsOK(res1)) {
41360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41361 }
41362 arg1 = reinterpret_cast< wxMenu * >(argp1);
41363 {
41364 PyThreadState* __tstate = wxPyBeginAllowThreads();
41365 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41366 wxPyEndAllowThreads(__tstate);
41367 if (PyErr_Occurred()) SWIG_fail;
41368 }
41369 {
41370 resultobj = wxPyMake_wxObject(result, 0);
41371 }
41372 return resultobj;
41373 fail:
41374 return NULL;
41375 }
41376
41377
41378 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41379 PyObject *resultobj = 0;
41380 wxMenu *arg1 = (wxMenu *) 0 ;
41381 long result;
41382 void *argp1 = 0 ;
41383 int res1 = 0 ;
41384 PyObject *swig_obj[1] ;
41385
41386 if (!args) SWIG_fail;
41387 swig_obj[0] = args;
41388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41389 if (!SWIG_IsOK(res1)) {
41390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41391 }
41392 arg1 = reinterpret_cast< wxMenu * >(argp1);
41393 {
41394 PyThreadState* __tstate = wxPyBeginAllowThreads();
41395 result = (long)((wxMenu const *)arg1)->GetStyle();
41396 wxPyEndAllowThreads(__tstate);
41397 if (PyErr_Occurred()) SWIG_fail;
41398 }
41399 resultobj = SWIG_From_long(static_cast< long >(result));
41400 return resultobj;
41401 fail:
41402 return NULL;
41403 }
41404
41405
41406 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41407 PyObject *resultobj = 0;
41408 wxMenu *arg1 = (wxMenu *) 0 ;
41409 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41410 void *argp1 = 0 ;
41411 int res1 = 0 ;
41412 void *argp2 = 0 ;
41413 int res2 = 0 ;
41414 PyObject * obj0 = 0 ;
41415 PyObject * obj1 = 0 ;
41416 char * kwnames[] = {
41417 (char *) "self",(char *) "source", NULL
41418 };
41419
41420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41422 if (!SWIG_IsOK(res1)) {
41423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41424 }
41425 arg1 = reinterpret_cast< wxMenu * >(argp1);
41426 if (obj1) {
41427 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41428 if (!SWIG_IsOK(res2)) {
41429 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41430 }
41431 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41432 }
41433 {
41434 PyThreadState* __tstate = wxPyBeginAllowThreads();
41435 (arg1)->UpdateUI(arg2);
41436 wxPyEndAllowThreads(__tstate);
41437 if (PyErr_Occurred()) SWIG_fail;
41438 }
41439 resultobj = SWIG_Py_Void();
41440 return resultobj;
41441 fail:
41442 return NULL;
41443 }
41444
41445
41446 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41447 PyObject *resultobj = 0;
41448 wxMenu *arg1 = (wxMenu *) 0 ;
41449 wxMenuBar *result = 0 ;
41450 void *argp1 = 0 ;
41451 int res1 = 0 ;
41452 PyObject *swig_obj[1] ;
41453
41454 if (!args) SWIG_fail;
41455 swig_obj[0] = args;
41456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41457 if (!SWIG_IsOK(res1)) {
41458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41459 }
41460 arg1 = reinterpret_cast< wxMenu * >(argp1);
41461 {
41462 PyThreadState* __tstate = wxPyBeginAllowThreads();
41463 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41464 wxPyEndAllowThreads(__tstate);
41465 if (PyErr_Occurred()) SWIG_fail;
41466 }
41467 {
41468 resultobj = wxPyMake_wxObject(result, (bool)0);
41469 }
41470 return resultobj;
41471 fail:
41472 return NULL;
41473 }
41474
41475
41476 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41477 PyObject *resultobj = 0;
41478 wxMenu *arg1 = (wxMenu *) 0 ;
41479 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41480 void *argp1 = 0 ;
41481 int res1 = 0 ;
41482 void *argp2 = 0 ;
41483 int res2 = 0 ;
41484 PyObject * obj0 = 0 ;
41485 PyObject * obj1 = 0 ;
41486 char * kwnames[] = {
41487 (char *) "self",(char *) "menubar", NULL
41488 };
41489
41490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41492 if (!SWIG_IsOK(res1)) {
41493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41494 }
41495 arg1 = reinterpret_cast< wxMenu * >(argp1);
41496 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41497 if (!SWIG_IsOK(res2)) {
41498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41499 }
41500 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41501 {
41502 PyThreadState* __tstate = wxPyBeginAllowThreads();
41503 (arg1)->Attach(arg2);
41504 wxPyEndAllowThreads(__tstate);
41505 if (PyErr_Occurred()) SWIG_fail;
41506 }
41507 resultobj = SWIG_Py_Void();
41508 return resultobj;
41509 fail:
41510 return NULL;
41511 }
41512
41513
41514 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41515 PyObject *resultobj = 0;
41516 wxMenu *arg1 = (wxMenu *) 0 ;
41517 void *argp1 = 0 ;
41518 int res1 = 0 ;
41519 PyObject *swig_obj[1] ;
41520
41521 if (!args) SWIG_fail;
41522 swig_obj[0] = args;
41523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41524 if (!SWIG_IsOK(res1)) {
41525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41526 }
41527 arg1 = reinterpret_cast< wxMenu * >(argp1);
41528 {
41529 PyThreadState* __tstate = wxPyBeginAllowThreads();
41530 (arg1)->Detach();
41531 wxPyEndAllowThreads(__tstate);
41532 if (PyErr_Occurred()) SWIG_fail;
41533 }
41534 resultobj = SWIG_Py_Void();
41535 return resultobj;
41536 fail:
41537 return NULL;
41538 }
41539
41540
41541 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41542 PyObject *resultobj = 0;
41543 wxMenu *arg1 = (wxMenu *) 0 ;
41544 bool result;
41545 void *argp1 = 0 ;
41546 int res1 = 0 ;
41547 PyObject *swig_obj[1] ;
41548
41549 if (!args) SWIG_fail;
41550 swig_obj[0] = args;
41551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41552 if (!SWIG_IsOK(res1)) {
41553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41554 }
41555 arg1 = reinterpret_cast< wxMenu * >(argp1);
41556 {
41557 PyThreadState* __tstate = wxPyBeginAllowThreads();
41558 result = (bool)((wxMenu const *)arg1)->IsAttached();
41559 wxPyEndAllowThreads(__tstate);
41560 if (PyErr_Occurred()) SWIG_fail;
41561 }
41562 {
41563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41564 }
41565 return resultobj;
41566 fail:
41567 return NULL;
41568 }
41569
41570
41571 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41572 PyObject *resultobj = 0;
41573 wxMenu *arg1 = (wxMenu *) 0 ;
41574 wxMenu *arg2 = (wxMenu *) 0 ;
41575 void *argp1 = 0 ;
41576 int res1 = 0 ;
41577 void *argp2 = 0 ;
41578 int res2 = 0 ;
41579 PyObject * obj0 = 0 ;
41580 PyObject * obj1 = 0 ;
41581 char * kwnames[] = {
41582 (char *) "self",(char *) "parent", NULL
41583 };
41584
41585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41587 if (!SWIG_IsOK(res1)) {
41588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41589 }
41590 arg1 = reinterpret_cast< wxMenu * >(argp1);
41591 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41592 if (!SWIG_IsOK(res2)) {
41593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41594 }
41595 arg2 = reinterpret_cast< wxMenu * >(argp2);
41596 {
41597 PyThreadState* __tstate = wxPyBeginAllowThreads();
41598 (arg1)->SetParent(arg2);
41599 wxPyEndAllowThreads(__tstate);
41600 if (PyErr_Occurred()) SWIG_fail;
41601 }
41602 resultobj = SWIG_Py_Void();
41603 return resultobj;
41604 fail:
41605 return NULL;
41606 }
41607
41608
41609 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41610 PyObject *resultobj = 0;
41611 wxMenu *arg1 = (wxMenu *) 0 ;
41612 wxMenu *result = 0 ;
41613 void *argp1 = 0 ;
41614 int res1 = 0 ;
41615 PyObject *swig_obj[1] ;
41616
41617 if (!args) SWIG_fail;
41618 swig_obj[0] = args;
41619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41620 if (!SWIG_IsOK(res1)) {
41621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41622 }
41623 arg1 = reinterpret_cast< wxMenu * >(argp1);
41624 {
41625 PyThreadState* __tstate = wxPyBeginAllowThreads();
41626 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41627 wxPyEndAllowThreads(__tstate);
41628 if (PyErr_Occurred()) SWIG_fail;
41629 }
41630 {
41631 resultobj = wxPyMake_wxObject(result, 0);
41632 }
41633 return resultobj;
41634 fail:
41635 return NULL;
41636 }
41637
41638
41639 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41640 PyObject *obj;
41641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41642 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41643 return SWIG_Py_Void();
41644 }
41645
41646 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41647 return SWIG_Python_InitShadowInstance(args);
41648 }
41649
41650 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41651 PyObject *resultobj = 0;
41652 long arg1 = (long) 0 ;
41653 wxMenuBar *result = 0 ;
41654 long val1 ;
41655 int ecode1 = 0 ;
41656 PyObject * obj0 = 0 ;
41657 char * kwnames[] = {
41658 (char *) "style", NULL
41659 };
41660
41661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41662 if (obj0) {
41663 ecode1 = SWIG_AsVal_long(obj0, &val1);
41664 if (!SWIG_IsOK(ecode1)) {
41665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41666 }
41667 arg1 = static_cast< long >(val1);
41668 }
41669 {
41670 if (!wxPyCheckForApp()) SWIG_fail;
41671 PyThreadState* __tstate = wxPyBeginAllowThreads();
41672 result = (wxMenuBar *)new wxMenuBar(arg1);
41673 wxPyEndAllowThreads(__tstate);
41674 if (PyErr_Occurred()) SWIG_fail;
41675 }
41676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41677 return resultobj;
41678 fail:
41679 return NULL;
41680 }
41681
41682
41683 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41684 PyObject *resultobj = 0;
41685 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41686 wxMenu *arg2 = (wxMenu *) 0 ;
41687 wxString *arg3 = 0 ;
41688 bool result;
41689 void *argp1 = 0 ;
41690 int res1 = 0 ;
41691 void *argp2 = 0 ;
41692 int res2 = 0 ;
41693 bool temp3 = false ;
41694 PyObject * obj0 = 0 ;
41695 PyObject * obj1 = 0 ;
41696 PyObject * obj2 = 0 ;
41697 char * kwnames[] = {
41698 (char *) "self",(char *) "menu",(char *) "title", NULL
41699 };
41700
41701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41703 if (!SWIG_IsOK(res1)) {
41704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41705 }
41706 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41707 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41708 if (!SWIG_IsOK(res2)) {
41709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41710 }
41711 arg2 = reinterpret_cast< wxMenu * >(argp2);
41712 {
41713 arg3 = wxString_in_helper(obj2);
41714 if (arg3 == NULL) SWIG_fail;
41715 temp3 = true;
41716 }
41717 {
41718 PyThreadState* __tstate = wxPyBeginAllowThreads();
41719 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41720 wxPyEndAllowThreads(__tstate);
41721 if (PyErr_Occurred()) SWIG_fail;
41722 }
41723 {
41724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41725 }
41726 {
41727 if (temp3)
41728 delete arg3;
41729 }
41730 return resultobj;
41731 fail:
41732 {
41733 if (temp3)
41734 delete arg3;
41735 }
41736 return NULL;
41737 }
41738
41739
41740 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41741 PyObject *resultobj = 0;
41742 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41743 size_t arg2 ;
41744 wxMenu *arg3 = (wxMenu *) 0 ;
41745 wxString *arg4 = 0 ;
41746 bool result;
41747 void *argp1 = 0 ;
41748 int res1 = 0 ;
41749 size_t val2 ;
41750 int ecode2 = 0 ;
41751 void *argp3 = 0 ;
41752 int res3 = 0 ;
41753 bool temp4 = false ;
41754 PyObject * obj0 = 0 ;
41755 PyObject * obj1 = 0 ;
41756 PyObject * obj2 = 0 ;
41757 PyObject * obj3 = 0 ;
41758 char * kwnames[] = {
41759 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41760 };
41761
41762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41764 if (!SWIG_IsOK(res1)) {
41765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41766 }
41767 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41768 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41769 if (!SWIG_IsOK(ecode2)) {
41770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41771 }
41772 arg2 = static_cast< size_t >(val2);
41773 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41774 if (!SWIG_IsOK(res3)) {
41775 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41776 }
41777 arg3 = reinterpret_cast< wxMenu * >(argp3);
41778 {
41779 arg4 = wxString_in_helper(obj3);
41780 if (arg4 == NULL) SWIG_fail;
41781 temp4 = true;
41782 }
41783 {
41784 PyThreadState* __tstate = wxPyBeginAllowThreads();
41785 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41786 wxPyEndAllowThreads(__tstate);
41787 if (PyErr_Occurred()) SWIG_fail;
41788 }
41789 {
41790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41791 }
41792 {
41793 if (temp4)
41794 delete arg4;
41795 }
41796 return resultobj;
41797 fail:
41798 {
41799 if (temp4)
41800 delete arg4;
41801 }
41802 return NULL;
41803 }
41804
41805
41806 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41807 PyObject *resultobj = 0;
41808 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41809 size_t result;
41810 void *argp1 = 0 ;
41811 int res1 = 0 ;
41812 PyObject *swig_obj[1] ;
41813
41814 if (!args) SWIG_fail;
41815 swig_obj[0] = args;
41816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41817 if (!SWIG_IsOK(res1)) {
41818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41819 }
41820 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41821 {
41822 PyThreadState* __tstate = wxPyBeginAllowThreads();
41823 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41824 wxPyEndAllowThreads(__tstate);
41825 if (PyErr_Occurred()) SWIG_fail;
41826 }
41827 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41828 return resultobj;
41829 fail:
41830 return NULL;
41831 }
41832
41833
41834 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41835 PyObject *resultobj = 0;
41836 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41837 size_t arg2 ;
41838 wxMenu *result = 0 ;
41839 void *argp1 = 0 ;
41840 int res1 = 0 ;
41841 size_t val2 ;
41842 int ecode2 = 0 ;
41843 PyObject * obj0 = 0 ;
41844 PyObject * obj1 = 0 ;
41845 char * kwnames[] = {
41846 (char *) "self",(char *) "pos", NULL
41847 };
41848
41849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41851 if (!SWIG_IsOK(res1)) {
41852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41853 }
41854 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41855 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41856 if (!SWIG_IsOK(ecode2)) {
41857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41858 }
41859 arg2 = static_cast< size_t >(val2);
41860 {
41861 PyThreadState* __tstate = wxPyBeginAllowThreads();
41862 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41863 wxPyEndAllowThreads(__tstate);
41864 if (PyErr_Occurred()) SWIG_fail;
41865 }
41866 {
41867 resultobj = wxPyMake_wxObject(result, 0);
41868 }
41869 return resultobj;
41870 fail:
41871 return NULL;
41872 }
41873
41874
41875 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41876 PyObject *resultobj = 0;
41877 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41878 size_t arg2 ;
41879 wxMenu *arg3 = (wxMenu *) 0 ;
41880 wxString *arg4 = 0 ;
41881 wxMenu *result = 0 ;
41882 void *argp1 = 0 ;
41883 int res1 = 0 ;
41884 size_t val2 ;
41885 int ecode2 = 0 ;
41886 void *argp3 = 0 ;
41887 int res3 = 0 ;
41888 bool temp4 = false ;
41889 PyObject * obj0 = 0 ;
41890 PyObject * obj1 = 0 ;
41891 PyObject * obj2 = 0 ;
41892 PyObject * obj3 = 0 ;
41893 char * kwnames[] = {
41894 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41895 };
41896
41897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41899 if (!SWIG_IsOK(res1)) {
41900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41901 }
41902 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41903 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41904 if (!SWIG_IsOK(ecode2)) {
41905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41906 }
41907 arg2 = static_cast< size_t >(val2);
41908 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41909 if (!SWIG_IsOK(res3)) {
41910 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41911 }
41912 arg3 = reinterpret_cast< wxMenu * >(argp3);
41913 {
41914 arg4 = wxString_in_helper(obj3);
41915 if (arg4 == NULL) SWIG_fail;
41916 temp4 = true;
41917 }
41918 {
41919 PyThreadState* __tstate = wxPyBeginAllowThreads();
41920 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41921 wxPyEndAllowThreads(__tstate);
41922 if (PyErr_Occurred()) SWIG_fail;
41923 }
41924 {
41925 resultobj = wxPyMake_wxObject(result, 0);
41926 }
41927 {
41928 if (temp4)
41929 delete arg4;
41930 }
41931 return resultobj;
41932 fail:
41933 {
41934 if (temp4)
41935 delete arg4;
41936 }
41937 return NULL;
41938 }
41939
41940
41941 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41942 PyObject *resultobj = 0;
41943 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41944 size_t arg2 ;
41945 wxMenu *result = 0 ;
41946 void *argp1 = 0 ;
41947 int res1 = 0 ;
41948 size_t val2 ;
41949 int ecode2 = 0 ;
41950 PyObject * obj0 = 0 ;
41951 PyObject * obj1 = 0 ;
41952 char * kwnames[] = {
41953 (char *) "self",(char *) "pos", NULL
41954 };
41955
41956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41958 if (!SWIG_IsOK(res1)) {
41959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41960 }
41961 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41962 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41963 if (!SWIG_IsOK(ecode2)) {
41964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41965 }
41966 arg2 = static_cast< size_t >(val2);
41967 {
41968 PyThreadState* __tstate = wxPyBeginAllowThreads();
41969 result = (wxMenu *)(arg1)->Remove(arg2);
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 {
41974 resultobj = wxPyMake_wxObject(result, 0);
41975 }
41976 return resultobj;
41977 fail:
41978 return NULL;
41979 }
41980
41981
41982 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41983 PyObject *resultobj = 0;
41984 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41985 size_t arg2 ;
41986 bool arg3 ;
41987 void *argp1 = 0 ;
41988 int res1 = 0 ;
41989 size_t val2 ;
41990 int ecode2 = 0 ;
41991 bool val3 ;
41992 int ecode3 = 0 ;
41993 PyObject * obj0 = 0 ;
41994 PyObject * obj1 = 0 ;
41995 PyObject * obj2 = 0 ;
41996 char * kwnames[] = {
41997 (char *) "self",(char *) "pos",(char *) "enable", NULL
41998 };
41999
42000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42002 if (!SWIG_IsOK(res1)) {
42003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42004 }
42005 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42006 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42007 if (!SWIG_IsOK(ecode2)) {
42008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42009 }
42010 arg2 = static_cast< size_t >(val2);
42011 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42012 if (!SWIG_IsOK(ecode3)) {
42013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42014 }
42015 arg3 = static_cast< bool >(val3);
42016 {
42017 PyThreadState* __tstate = wxPyBeginAllowThreads();
42018 (arg1)->EnableTop(arg2,arg3);
42019 wxPyEndAllowThreads(__tstate);
42020 if (PyErr_Occurred()) SWIG_fail;
42021 }
42022 resultobj = SWIG_Py_Void();
42023 return resultobj;
42024 fail:
42025 return NULL;
42026 }
42027
42028
42029 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42030 PyObject *resultobj = 0;
42031 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42032 size_t arg2 ;
42033 bool result;
42034 void *argp1 = 0 ;
42035 int res1 = 0 ;
42036 size_t val2 ;
42037 int ecode2 = 0 ;
42038 PyObject * obj0 = 0 ;
42039 PyObject * obj1 = 0 ;
42040 char * kwnames[] = {
42041 (char *) "self",(char *) "pos", NULL
42042 };
42043
42044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42046 if (!SWIG_IsOK(res1)) {
42047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42048 }
42049 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42050 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42051 if (!SWIG_IsOK(ecode2)) {
42052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42053 }
42054 arg2 = static_cast< size_t >(val2);
42055 {
42056 PyThreadState* __tstate = wxPyBeginAllowThreads();
42057 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42058 wxPyEndAllowThreads(__tstate);
42059 if (PyErr_Occurred()) SWIG_fail;
42060 }
42061 {
42062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42063 }
42064 return resultobj;
42065 fail:
42066 return NULL;
42067 }
42068
42069
42070 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42071 PyObject *resultobj = 0;
42072 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42073 size_t arg2 ;
42074 wxString *arg3 = 0 ;
42075 void *argp1 = 0 ;
42076 int res1 = 0 ;
42077 size_t val2 ;
42078 int ecode2 = 0 ;
42079 bool temp3 = false ;
42080 PyObject * obj0 = 0 ;
42081 PyObject * obj1 = 0 ;
42082 PyObject * obj2 = 0 ;
42083 char * kwnames[] = {
42084 (char *) "self",(char *) "pos",(char *) "label", NULL
42085 };
42086
42087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42089 if (!SWIG_IsOK(res1)) {
42090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42091 }
42092 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42093 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42094 if (!SWIG_IsOK(ecode2)) {
42095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42096 }
42097 arg2 = static_cast< size_t >(val2);
42098 {
42099 arg3 = wxString_in_helper(obj2);
42100 if (arg3 == NULL) SWIG_fail;
42101 temp3 = true;
42102 }
42103 {
42104 PyThreadState* __tstate = wxPyBeginAllowThreads();
42105 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42106 wxPyEndAllowThreads(__tstate);
42107 if (PyErr_Occurred()) SWIG_fail;
42108 }
42109 resultobj = SWIG_Py_Void();
42110 {
42111 if (temp3)
42112 delete arg3;
42113 }
42114 return resultobj;
42115 fail:
42116 {
42117 if (temp3)
42118 delete arg3;
42119 }
42120 return NULL;
42121 }
42122
42123
42124 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42125 PyObject *resultobj = 0;
42126 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42127 size_t arg2 ;
42128 wxString result;
42129 void *argp1 = 0 ;
42130 int res1 = 0 ;
42131 size_t val2 ;
42132 int ecode2 = 0 ;
42133 PyObject * obj0 = 0 ;
42134 PyObject * obj1 = 0 ;
42135 char * kwnames[] = {
42136 (char *) "self",(char *) "pos", NULL
42137 };
42138
42139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42141 if (!SWIG_IsOK(res1)) {
42142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42143 }
42144 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42145 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42146 if (!SWIG_IsOK(ecode2)) {
42147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42148 }
42149 arg2 = static_cast< size_t >(val2);
42150 {
42151 PyThreadState* __tstate = wxPyBeginAllowThreads();
42152 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42153 wxPyEndAllowThreads(__tstate);
42154 if (PyErr_Occurred()) SWIG_fail;
42155 }
42156 {
42157 #if wxUSE_UNICODE
42158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42159 #else
42160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42161 #endif
42162 }
42163 return resultobj;
42164 fail:
42165 return NULL;
42166 }
42167
42168
42169 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42170 PyObject *resultobj = 0;
42171 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42172 wxString *arg2 = 0 ;
42173 wxString *arg3 = 0 ;
42174 int result;
42175 void *argp1 = 0 ;
42176 int res1 = 0 ;
42177 bool temp2 = false ;
42178 bool temp3 = false ;
42179 PyObject * obj0 = 0 ;
42180 PyObject * obj1 = 0 ;
42181 PyObject * obj2 = 0 ;
42182 char * kwnames[] = {
42183 (char *) "self",(char *) "menu",(char *) "item", NULL
42184 };
42185
42186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42188 if (!SWIG_IsOK(res1)) {
42189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42190 }
42191 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42192 {
42193 arg2 = wxString_in_helper(obj1);
42194 if (arg2 == NULL) SWIG_fail;
42195 temp2 = true;
42196 }
42197 {
42198 arg3 = wxString_in_helper(obj2);
42199 if (arg3 == NULL) SWIG_fail;
42200 temp3 = true;
42201 }
42202 {
42203 PyThreadState* __tstate = wxPyBeginAllowThreads();
42204 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42205 wxPyEndAllowThreads(__tstate);
42206 if (PyErr_Occurred()) SWIG_fail;
42207 }
42208 resultobj = SWIG_From_int(static_cast< int >(result));
42209 {
42210 if (temp2)
42211 delete arg2;
42212 }
42213 {
42214 if (temp3)
42215 delete arg3;
42216 }
42217 return resultobj;
42218 fail:
42219 {
42220 if (temp2)
42221 delete arg2;
42222 }
42223 {
42224 if (temp3)
42225 delete arg3;
42226 }
42227 return NULL;
42228 }
42229
42230
42231 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42232 PyObject *resultobj = 0;
42233 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42234 int arg2 ;
42235 wxMenuItem *result = 0 ;
42236 void *argp1 = 0 ;
42237 int res1 = 0 ;
42238 int val2 ;
42239 int ecode2 = 0 ;
42240 PyObject * obj0 = 0 ;
42241 PyObject * obj1 = 0 ;
42242 char * kwnames[] = {
42243 (char *) "self",(char *) "id", NULL
42244 };
42245
42246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42248 if (!SWIG_IsOK(res1)) {
42249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42250 }
42251 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42252 ecode2 = SWIG_AsVal_int(obj1, &val2);
42253 if (!SWIG_IsOK(ecode2)) {
42254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42255 }
42256 arg2 = static_cast< int >(val2);
42257 {
42258 PyThreadState* __tstate = wxPyBeginAllowThreads();
42259 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42260 wxPyEndAllowThreads(__tstate);
42261 if (PyErr_Occurred()) SWIG_fail;
42262 }
42263 {
42264 resultobj = wxPyMake_wxObject(result, (bool)0);
42265 }
42266 return resultobj;
42267 fail:
42268 return NULL;
42269 }
42270
42271
42272 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42273 PyObject *resultobj = 0;
42274 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42275 wxString *arg2 = 0 ;
42276 int result;
42277 void *argp1 = 0 ;
42278 int res1 = 0 ;
42279 bool temp2 = false ;
42280 PyObject * obj0 = 0 ;
42281 PyObject * obj1 = 0 ;
42282 char * kwnames[] = {
42283 (char *) "self",(char *) "title", NULL
42284 };
42285
42286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42288 if (!SWIG_IsOK(res1)) {
42289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42290 }
42291 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42292 {
42293 arg2 = wxString_in_helper(obj1);
42294 if (arg2 == NULL) SWIG_fail;
42295 temp2 = true;
42296 }
42297 {
42298 PyThreadState* __tstate = wxPyBeginAllowThreads();
42299 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42300 wxPyEndAllowThreads(__tstate);
42301 if (PyErr_Occurred()) SWIG_fail;
42302 }
42303 resultobj = SWIG_From_int(static_cast< int >(result));
42304 {
42305 if (temp2)
42306 delete arg2;
42307 }
42308 return resultobj;
42309 fail:
42310 {
42311 if (temp2)
42312 delete arg2;
42313 }
42314 return NULL;
42315 }
42316
42317
42318 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42319 PyObject *resultobj = 0;
42320 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42321 int arg2 ;
42322 bool arg3 ;
42323 void *argp1 = 0 ;
42324 int res1 = 0 ;
42325 int val2 ;
42326 int ecode2 = 0 ;
42327 bool val3 ;
42328 int ecode3 = 0 ;
42329 PyObject * obj0 = 0 ;
42330 PyObject * obj1 = 0 ;
42331 PyObject * obj2 = 0 ;
42332 char * kwnames[] = {
42333 (char *) "self",(char *) "id",(char *) "enable", NULL
42334 };
42335
42336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42338 if (!SWIG_IsOK(res1)) {
42339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42340 }
42341 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42342 ecode2 = SWIG_AsVal_int(obj1, &val2);
42343 if (!SWIG_IsOK(ecode2)) {
42344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42345 }
42346 arg2 = static_cast< int >(val2);
42347 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42348 if (!SWIG_IsOK(ecode3)) {
42349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42350 }
42351 arg3 = static_cast< bool >(val3);
42352 {
42353 PyThreadState* __tstate = wxPyBeginAllowThreads();
42354 (arg1)->Enable(arg2,arg3);
42355 wxPyEndAllowThreads(__tstate);
42356 if (PyErr_Occurred()) SWIG_fail;
42357 }
42358 resultobj = SWIG_Py_Void();
42359 return resultobj;
42360 fail:
42361 return NULL;
42362 }
42363
42364
42365 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42366 PyObject *resultobj = 0;
42367 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42368 int arg2 ;
42369 bool arg3 ;
42370 void *argp1 = 0 ;
42371 int res1 = 0 ;
42372 int val2 ;
42373 int ecode2 = 0 ;
42374 bool val3 ;
42375 int ecode3 = 0 ;
42376 PyObject * obj0 = 0 ;
42377 PyObject * obj1 = 0 ;
42378 PyObject * obj2 = 0 ;
42379 char * kwnames[] = {
42380 (char *) "self",(char *) "id",(char *) "check", NULL
42381 };
42382
42383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42385 if (!SWIG_IsOK(res1)) {
42386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42387 }
42388 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42389 ecode2 = SWIG_AsVal_int(obj1, &val2);
42390 if (!SWIG_IsOK(ecode2)) {
42391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42392 }
42393 arg2 = static_cast< int >(val2);
42394 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42395 if (!SWIG_IsOK(ecode3)) {
42396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42397 }
42398 arg3 = static_cast< bool >(val3);
42399 {
42400 PyThreadState* __tstate = wxPyBeginAllowThreads();
42401 (arg1)->Check(arg2,arg3);
42402 wxPyEndAllowThreads(__tstate);
42403 if (PyErr_Occurred()) SWIG_fail;
42404 }
42405 resultobj = SWIG_Py_Void();
42406 return resultobj;
42407 fail:
42408 return NULL;
42409 }
42410
42411
42412 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42413 PyObject *resultobj = 0;
42414 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42415 int arg2 ;
42416 bool result;
42417 void *argp1 = 0 ;
42418 int res1 = 0 ;
42419 int val2 ;
42420 int ecode2 = 0 ;
42421 PyObject * obj0 = 0 ;
42422 PyObject * obj1 = 0 ;
42423 char * kwnames[] = {
42424 (char *) "self",(char *) "id", NULL
42425 };
42426
42427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42429 if (!SWIG_IsOK(res1)) {
42430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42431 }
42432 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42433 ecode2 = SWIG_AsVal_int(obj1, &val2);
42434 if (!SWIG_IsOK(ecode2)) {
42435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42436 }
42437 arg2 = static_cast< int >(val2);
42438 {
42439 PyThreadState* __tstate = wxPyBeginAllowThreads();
42440 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42441 wxPyEndAllowThreads(__tstate);
42442 if (PyErr_Occurred()) SWIG_fail;
42443 }
42444 {
42445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42446 }
42447 return resultobj;
42448 fail:
42449 return NULL;
42450 }
42451
42452
42453 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42454 PyObject *resultobj = 0;
42455 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42456 int arg2 ;
42457 bool result;
42458 void *argp1 = 0 ;
42459 int res1 = 0 ;
42460 int val2 ;
42461 int ecode2 = 0 ;
42462 PyObject * obj0 = 0 ;
42463 PyObject * obj1 = 0 ;
42464 char * kwnames[] = {
42465 (char *) "self",(char *) "id", NULL
42466 };
42467
42468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42470 if (!SWIG_IsOK(res1)) {
42471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42472 }
42473 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42474 ecode2 = SWIG_AsVal_int(obj1, &val2);
42475 if (!SWIG_IsOK(ecode2)) {
42476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42477 }
42478 arg2 = static_cast< int >(val2);
42479 {
42480 PyThreadState* __tstate = wxPyBeginAllowThreads();
42481 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42482 wxPyEndAllowThreads(__tstate);
42483 if (PyErr_Occurred()) SWIG_fail;
42484 }
42485 {
42486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42487 }
42488 return resultobj;
42489 fail:
42490 return NULL;
42491 }
42492
42493
42494 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42495 PyObject *resultobj = 0;
42496 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42497 int arg2 ;
42498 wxString *arg3 = 0 ;
42499 void *argp1 = 0 ;
42500 int res1 = 0 ;
42501 int val2 ;
42502 int ecode2 = 0 ;
42503 bool temp3 = false ;
42504 PyObject * obj0 = 0 ;
42505 PyObject * obj1 = 0 ;
42506 PyObject * obj2 = 0 ;
42507 char * kwnames[] = {
42508 (char *) "self",(char *) "id",(char *) "label", NULL
42509 };
42510
42511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42513 if (!SWIG_IsOK(res1)) {
42514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42515 }
42516 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42517 ecode2 = SWIG_AsVal_int(obj1, &val2);
42518 if (!SWIG_IsOK(ecode2)) {
42519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42520 }
42521 arg2 = static_cast< int >(val2);
42522 {
42523 arg3 = wxString_in_helper(obj2);
42524 if (arg3 == NULL) SWIG_fail;
42525 temp3 = true;
42526 }
42527 {
42528 PyThreadState* __tstate = wxPyBeginAllowThreads();
42529 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42530 wxPyEndAllowThreads(__tstate);
42531 if (PyErr_Occurred()) SWIG_fail;
42532 }
42533 resultobj = SWIG_Py_Void();
42534 {
42535 if (temp3)
42536 delete arg3;
42537 }
42538 return resultobj;
42539 fail:
42540 {
42541 if (temp3)
42542 delete arg3;
42543 }
42544 return NULL;
42545 }
42546
42547
42548 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42549 PyObject *resultobj = 0;
42550 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42551 int arg2 ;
42552 wxString result;
42553 void *argp1 = 0 ;
42554 int res1 = 0 ;
42555 int val2 ;
42556 int ecode2 = 0 ;
42557 PyObject * obj0 = 0 ;
42558 PyObject * obj1 = 0 ;
42559 char * kwnames[] = {
42560 (char *) "self",(char *) "id", NULL
42561 };
42562
42563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42565 if (!SWIG_IsOK(res1)) {
42566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42567 }
42568 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42569 ecode2 = SWIG_AsVal_int(obj1, &val2);
42570 if (!SWIG_IsOK(ecode2)) {
42571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42572 }
42573 arg2 = static_cast< int >(val2);
42574 {
42575 PyThreadState* __tstate = wxPyBeginAllowThreads();
42576 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42577 wxPyEndAllowThreads(__tstate);
42578 if (PyErr_Occurred()) SWIG_fail;
42579 }
42580 {
42581 #if wxUSE_UNICODE
42582 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42583 #else
42584 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42585 #endif
42586 }
42587 return resultobj;
42588 fail:
42589 return NULL;
42590 }
42591
42592
42593 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42594 PyObject *resultobj = 0;
42595 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42596 int arg2 ;
42597 wxString *arg3 = 0 ;
42598 void *argp1 = 0 ;
42599 int res1 = 0 ;
42600 int val2 ;
42601 int ecode2 = 0 ;
42602 bool temp3 = false ;
42603 PyObject * obj0 = 0 ;
42604 PyObject * obj1 = 0 ;
42605 PyObject * obj2 = 0 ;
42606 char * kwnames[] = {
42607 (char *) "self",(char *) "id",(char *) "helpString", NULL
42608 };
42609
42610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42612 if (!SWIG_IsOK(res1)) {
42613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42614 }
42615 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42616 ecode2 = SWIG_AsVal_int(obj1, &val2);
42617 if (!SWIG_IsOK(ecode2)) {
42618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42619 }
42620 arg2 = static_cast< int >(val2);
42621 {
42622 arg3 = wxString_in_helper(obj2);
42623 if (arg3 == NULL) SWIG_fail;
42624 temp3 = true;
42625 }
42626 {
42627 PyThreadState* __tstate = wxPyBeginAllowThreads();
42628 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42629 wxPyEndAllowThreads(__tstate);
42630 if (PyErr_Occurred()) SWIG_fail;
42631 }
42632 resultobj = SWIG_Py_Void();
42633 {
42634 if (temp3)
42635 delete arg3;
42636 }
42637 return resultobj;
42638 fail:
42639 {
42640 if (temp3)
42641 delete arg3;
42642 }
42643 return NULL;
42644 }
42645
42646
42647 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42648 PyObject *resultobj = 0;
42649 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42650 int arg2 ;
42651 wxString result;
42652 void *argp1 = 0 ;
42653 int res1 = 0 ;
42654 int val2 ;
42655 int ecode2 = 0 ;
42656 PyObject * obj0 = 0 ;
42657 PyObject * obj1 = 0 ;
42658 char * kwnames[] = {
42659 (char *) "self",(char *) "id", NULL
42660 };
42661
42662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42664 if (!SWIG_IsOK(res1)) {
42665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42666 }
42667 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42668 ecode2 = SWIG_AsVal_int(obj1, &val2);
42669 if (!SWIG_IsOK(ecode2)) {
42670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42671 }
42672 arg2 = static_cast< int >(val2);
42673 {
42674 PyThreadState* __tstate = wxPyBeginAllowThreads();
42675 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42676 wxPyEndAllowThreads(__tstate);
42677 if (PyErr_Occurred()) SWIG_fail;
42678 }
42679 {
42680 #if wxUSE_UNICODE
42681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42682 #else
42683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42684 #endif
42685 }
42686 return resultobj;
42687 fail:
42688 return NULL;
42689 }
42690
42691
42692 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42693 PyObject *resultobj = 0;
42694 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42695 wxFrame *result = 0 ;
42696 void *argp1 = 0 ;
42697 int res1 = 0 ;
42698 PyObject *swig_obj[1] ;
42699
42700 if (!args) SWIG_fail;
42701 swig_obj[0] = args;
42702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42703 if (!SWIG_IsOK(res1)) {
42704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42705 }
42706 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42707 {
42708 PyThreadState* __tstate = wxPyBeginAllowThreads();
42709 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42710 wxPyEndAllowThreads(__tstate);
42711 if (PyErr_Occurred()) SWIG_fail;
42712 }
42713 {
42714 resultobj = wxPyMake_wxObject(result, (bool)0);
42715 }
42716 return resultobj;
42717 fail:
42718 return NULL;
42719 }
42720
42721
42722 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42723 PyObject *resultobj = 0;
42724 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42725 bool result;
42726 void *argp1 = 0 ;
42727 int res1 = 0 ;
42728 PyObject *swig_obj[1] ;
42729
42730 if (!args) SWIG_fail;
42731 swig_obj[0] = args;
42732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42733 if (!SWIG_IsOK(res1)) {
42734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42735 }
42736 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42737 {
42738 PyThreadState* __tstate = wxPyBeginAllowThreads();
42739 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42740 wxPyEndAllowThreads(__tstate);
42741 if (PyErr_Occurred()) SWIG_fail;
42742 }
42743 {
42744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42745 }
42746 return resultobj;
42747 fail:
42748 return NULL;
42749 }
42750
42751
42752 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42753 PyObject *resultobj = 0;
42754 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42755 wxFrame *arg2 = (wxFrame *) 0 ;
42756 void *argp1 = 0 ;
42757 int res1 = 0 ;
42758 void *argp2 = 0 ;
42759 int res2 = 0 ;
42760 PyObject * obj0 = 0 ;
42761 PyObject * obj1 = 0 ;
42762 char * kwnames[] = {
42763 (char *) "self",(char *) "frame", NULL
42764 };
42765
42766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42768 if (!SWIG_IsOK(res1)) {
42769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42770 }
42771 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42773 if (!SWIG_IsOK(res2)) {
42774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42775 }
42776 arg2 = reinterpret_cast< wxFrame * >(argp2);
42777 {
42778 PyThreadState* __tstate = wxPyBeginAllowThreads();
42779 (arg1)->Attach(arg2);
42780 wxPyEndAllowThreads(__tstate);
42781 if (PyErr_Occurred()) SWIG_fail;
42782 }
42783 resultobj = SWIG_Py_Void();
42784 return resultobj;
42785 fail:
42786 return NULL;
42787 }
42788
42789
42790 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42791 PyObject *resultobj = 0;
42792 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42793 void *argp1 = 0 ;
42794 int res1 = 0 ;
42795 PyObject *swig_obj[1] ;
42796
42797 if (!args) SWIG_fail;
42798 swig_obj[0] = args;
42799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42800 if (!SWIG_IsOK(res1)) {
42801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42802 }
42803 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42804 {
42805 PyThreadState* __tstate = wxPyBeginAllowThreads();
42806 (arg1)->Detach();
42807 wxPyEndAllowThreads(__tstate);
42808 if (PyErr_Occurred()) SWIG_fail;
42809 }
42810 resultobj = SWIG_Py_Void();
42811 return resultobj;
42812 fail:
42813 return NULL;
42814 }
42815
42816
42817 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42818 PyObject *resultobj = 0;
42819 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42820 void *argp1 = 0 ;
42821 int res1 = 0 ;
42822 PyObject *swig_obj[1] ;
42823
42824 if (!args) SWIG_fail;
42825 swig_obj[0] = args;
42826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42827 if (!SWIG_IsOK(res1)) {
42828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42829 }
42830 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42831 {
42832 PyThreadState* __tstate = wxPyBeginAllowThreads();
42833 (arg1)->UpdateMenus();
42834 wxPyEndAllowThreads(__tstate);
42835 if (PyErr_Occurred()) SWIG_fail;
42836 }
42837 resultobj = SWIG_Py_Void();
42838 return resultobj;
42839 fail:
42840 return NULL;
42841 }
42842
42843
42844 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42845 PyObject *resultobj = 0;
42846 bool arg1 ;
42847 bool val1 ;
42848 int ecode1 = 0 ;
42849 PyObject * obj0 = 0 ;
42850 char * kwnames[] = {
42851 (char *) "enable", NULL
42852 };
42853
42854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42855 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42856 if (!SWIG_IsOK(ecode1)) {
42857 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42858 }
42859 arg1 = static_cast< bool >(val1);
42860 {
42861 PyThreadState* __tstate = wxPyBeginAllowThreads();
42862 wxMenuBar::SetAutoWindowMenu(arg1);
42863 wxPyEndAllowThreads(__tstate);
42864 if (PyErr_Occurred()) SWIG_fail;
42865 }
42866 resultobj = SWIG_Py_Void();
42867 return resultobj;
42868 fail:
42869 return NULL;
42870 }
42871
42872
42873 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42874 PyObject *resultobj = 0;
42875 bool result;
42876
42877 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42878 {
42879 PyThreadState* __tstate = wxPyBeginAllowThreads();
42880 result = (bool)wxMenuBar::GetAutoWindowMenu();
42881 wxPyEndAllowThreads(__tstate);
42882 if (PyErr_Occurred()) SWIG_fail;
42883 }
42884 {
42885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42886 }
42887 return resultobj;
42888 fail:
42889 return NULL;
42890 }
42891
42892
42893 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42894 PyObject *obj;
42895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42896 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42897 return SWIG_Py_Void();
42898 }
42899
42900 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42901 return SWIG_Python_InitShadowInstance(args);
42902 }
42903
42904 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42905 PyObject *resultobj = 0;
42906 wxMenu *arg1 = (wxMenu *) NULL ;
42907 int arg2 = (int) wxID_ANY ;
42908 wxString const &arg3_defvalue = wxPyEmptyString ;
42909 wxString *arg3 = (wxString *) &arg3_defvalue ;
42910 wxString const &arg4_defvalue = wxPyEmptyString ;
42911 wxString *arg4 = (wxString *) &arg4_defvalue ;
42912 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42913 wxMenu *arg6 = (wxMenu *) NULL ;
42914 wxMenuItem *result = 0 ;
42915 void *argp1 = 0 ;
42916 int res1 = 0 ;
42917 int val2 ;
42918 int ecode2 = 0 ;
42919 bool temp3 = false ;
42920 bool temp4 = false ;
42921 int val5 ;
42922 int ecode5 = 0 ;
42923 void *argp6 = 0 ;
42924 int res6 = 0 ;
42925 PyObject * obj0 = 0 ;
42926 PyObject * obj1 = 0 ;
42927 PyObject * obj2 = 0 ;
42928 PyObject * obj3 = 0 ;
42929 PyObject * obj4 = 0 ;
42930 PyObject * obj5 = 0 ;
42931 char * kwnames[] = {
42932 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42933 };
42934
42935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42936 if (obj0) {
42937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42938 if (!SWIG_IsOK(res1)) {
42939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42940 }
42941 arg1 = reinterpret_cast< wxMenu * >(argp1);
42942 }
42943 if (obj1) {
42944 ecode2 = SWIG_AsVal_int(obj1, &val2);
42945 if (!SWIG_IsOK(ecode2)) {
42946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42947 }
42948 arg2 = static_cast< int >(val2);
42949 }
42950 if (obj2) {
42951 {
42952 arg3 = wxString_in_helper(obj2);
42953 if (arg3 == NULL) SWIG_fail;
42954 temp3 = true;
42955 }
42956 }
42957 if (obj3) {
42958 {
42959 arg4 = wxString_in_helper(obj3);
42960 if (arg4 == NULL) SWIG_fail;
42961 temp4 = true;
42962 }
42963 }
42964 if (obj4) {
42965 ecode5 = SWIG_AsVal_int(obj4, &val5);
42966 if (!SWIG_IsOK(ecode5)) {
42967 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42968 }
42969 arg5 = static_cast< wxItemKind >(val5);
42970 }
42971 if (obj5) {
42972 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42973 if (!SWIG_IsOK(res6)) {
42974 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42975 }
42976 arg6 = reinterpret_cast< wxMenu * >(argp6);
42977 }
42978 {
42979 PyThreadState* __tstate = wxPyBeginAllowThreads();
42980 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42981 wxPyEndAllowThreads(__tstate);
42982 if (PyErr_Occurred()) SWIG_fail;
42983 }
42984 {
42985 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42986 }
42987 {
42988 if (temp3)
42989 delete arg3;
42990 }
42991 {
42992 if (temp4)
42993 delete arg4;
42994 }
42995 return resultobj;
42996 fail:
42997 {
42998 if (temp3)
42999 delete arg3;
43000 }
43001 {
43002 if (temp4)
43003 delete arg4;
43004 }
43005 return NULL;
43006 }
43007
43008
43009 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43010 PyObject *resultobj = 0;
43011 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43012 void *argp1 = 0 ;
43013 int res1 = 0 ;
43014 PyObject *swig_obj[1] ;
43015
43016 if (!args) SWIG_fail;
43017 swig_obj[0] = args;
43018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43019 if (!SWIG_IsOK(res1)) {
43020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43021 }
43022 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43023 {
43024 PyThreadState* __tstate = wxPyBeginAllowThreads();
43025 delete arg1;
43026
43027 wxPyEndAllowThreads(__tstate);
43028 if (PyErr_Occurred()) SWIG_fail;
43029 }
43030 resultobj = SWIG_Py_Void();
43031 return resultobj;
43032 fail:
43033 return NULL;
43034 }
43035
43036
43037 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43038 PyObject *resultobj = 0;
43039 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43040 wxMenu *result = 0 ;
43041 void *argp1 = 0 ;
43042 int res1 = 0 ;
43043 PyObject *swig_obj[1] ;
43044
43045 if (!args) SWIG_fail;
43046 swig_obj[0] = args;
43047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43048 if (!SWIG_IsOK(res1)) {
43049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43050 }
43051 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43052 {
43053 PyThreadState* __tstate = wxPyBeginAllowThreads();
43054 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43055 wxPyEndAllowThreads(__tstate);
43056 if (PyErr_Occurred()) SWIG_fail;
43057 }
43058 {
43059 resultobj = wxPyMake_wxObject(result, 0);
43060 }
43061 return resultobj;
43062 fail:
43063 return NULL;
43064 }
43065
43066
43067 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43068 PyObject *resultobj = 0;
43069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43070 wxMenu *arg2 = (wxMenu *) 0 ;
43071 void *argp1 = 0 ;
43072 int res1 = 0 ;
43073 void *argp2 = 0 ;
43074 int res2 = 0 ;
43075 PyObject * obj0 = 0 ;
43076 PyObject * obj1 = 0 ;
43077 char * kwnames[] = {
43078 (char *) "self",(char *) "menu", NULL
43079 };
43080
43081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43083 if (!SWIG_IsOK(res1)) {
43084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43085 }
43086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43088 if (!SWIG_IsOK(res2)) {
43089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43090 }
43091 arg2 = reinterpret_cast< wxMenu * >(argp2);
43092 {
43093 PyThreadState* __tstate = wxPyBeginAllowThreads();
43094 (arg1)->SetMenu(arg2);
43095 wxPyEndAllowThreads(__tstate);
43096 if (PyErr_Occurred()) SWIG_fail;
43097 }
43098 resultobj = SWIG_Py_Void();
43099 return resultobj;
43100 fail:
43101 return NULL;
43102 }
43103
43104
43105 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43106 PyObject *resultobj = 0;
43107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43108 int arg2 ;
43109 void *argp1 = 0 ;
43110 int res1 = 0 ;
43111 int val2 ;
43112 int ecode2 = 0 ;
43113 PyObject * obj0 = 0 ;
43114 PyObject * obj1 = 0 ;
43115 char * kwnames[] = {
43116 (char *) "self",(char *) "id", NULL
43117 };
43118
43119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43121 if (!SWIG_IsOK(res1)) {
43122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43123 }
43124 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43125 ecode2 = SWIG_AsVal_int(obj1, &val2);
43126 if (!SWIG_IsOK(ecode2)) {
43127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43128 }
43129 arg2 = static_cast< int >(val2);
43130 {
43131 PyThreadState* __tstate = wxPyBeginAllowThreads();
43132 (arg1)->SetId(arg2);
43133 wxPyEndAllowThreads(__tstate);
43134 if (PyErr_Occurred()) SWIG_fail;
43135 }
43136 resultobj = SWIG_Py_Void();
43137 return resultobj;
43138 fail:
43139 return NULL;
43140 }
43141
43142
43143 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43144 PyObject *resultobj = 0;
43145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43146 int result;
43147 void *argp1 = 0 ;
43148 int res1 = 0 ;
43149 PyObject *swig_obj[1] ;
43150
43151 if (!args) SWIG_fail;
43152 swig_obj[0] = args;
43153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43154 if (!SWIG_IsOK(res1)) {
43155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43156 }
43157 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43158 {
43159 PyThreadState* __tstate = wxPyBeginAllowThreads();
43160 result = (int)((wxMenuItem const *)arg1)->GetId();
43161 wxPyEndAllowThreads(__tstate);
43162 if (PyErr_Occurred()) SWIG_fail;
43163 }
43164 resultobj = SWIG_From_int(static_cast< int >(result));
43165 return resultobj;
43166 fail:
43167 return NULL;
43168 }
43169
43170
43171 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43172 PyObject *resultobj = 0;
43173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43174 bool result;
43175 void *argp1 = 0 ;
43176 int res1 = 0 ;
43177 PyObject *swig_obj[1] ;
43178
43179 if (!args) SWIG_fail;
43180 swig_obj[0] = args;
43181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43182 if (!SWIG_IsOK(res1)) {
43183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43184 }
43185 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43186 {
43187 PyThreadState* __tstate = wxPyBeginAllowThreads();
43188 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43189 wxPyEndAllowThreads(__tstate);
43190 if (PyErr_Occurred()) SWIG_fail;
43191 }
43192 {
43193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43194 }
43195 return resultobj;
43196 fail:
43197 return NULL;
43198 }
43199
43200
43201 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43202 PyObject *resultobj = 0;
43203 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43204 wxString *arg2 = 0 ;
43205 void *argp1 = 0 ;
43206 int res1 = 0 ;
43207 bool temp2 = false ;
43208 PyObject * obj0 = 0 ;
43209 PyObject * obj1 = 0 ;
43210 char * kwnames[] = {
43211 (char *) "self",(char *) "str", NULL
43212 };
43213
43214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43216 if (!SWIG_IsOK(res1)) {
43217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43218 }
43219 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43220 {
43221 arg2 = wxString_in_helper(obj1);
43222 if (arg2 == NULL) SWIG_fail;
43223 temp2 = true;
43224 }
43225 {
43226 PyThreadState* __tstate = wxPyBeginAllowThreads();
43227 (arg1)->SetText((wxString const &)*arg2);
43228 wxPyEndAllowThreads(__tstate);
43229 if (PyErr_Occurred()) SWIG_fail;
43230 }
43231 resultobj = SWIG_Py_Void();
43232 {
43233 if (temp2)
43234 delete arg2;
43235 }
43236 return resultobj;
43237 fail:
43238 {
43239 if (temp2)
43240 delete arg2;
43241 }
43242 return NULL;
43243 }
43244
43245
43246 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43247 PyObject *resultobj = 0;
43248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43249 wxString result;
43250 void *argp1 = 0 ;
43251 int res1 = 0 ;
43252 PyObject *swig_obj[1] ;
43253
43254 if (!args) SWIG_fail;
43255 swig_obj[0] = args;
43256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43257 if (!SWIG_IsOK(res1)) {
43258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43259 }
43260 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43261 {
43262 PyThreadState* __tstate = wxPyBeginAllowThreads();
43263 result = ((wxMenuItem const *)arg1)->GetLabel();
43264 wxPyEndAllowThreads(__tstate);
43265 if (PyErr_Occurred()) SWIG_fail;
43266 }
43267 {
43268 #if wxUSE_UNICODE
43269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43270 #else
43271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43272 #endif
43273 }
43274 return resultobj;
43275 fail:
43276 return NULL;
43277 }
43278
43279
43280 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43281 PyObject *resultobj = 0;
43282 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43283 wxString *result = 0 ;
43284 void *argp1 = 0 ;
43285 int res1 = 0 ;
43286 PyObject *swig_obj[1] ;
43287
43288 if (!args) SWIG_fail;
43289 swig_obj[0] = args;
43290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43291 if (!SWIG_IsOK(res1)) {
43292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43293 }
43294 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43295 {
43296 PyThreadState* __tstate = wxPyBeginAllowThreads();
43297 {
43298 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43299 result = (wxString *) &_result_ref;
43300 }
43301 wxPyEndAllowThreads(__tstate);
43302 if (PyErr_Occurred()) SWIG_fail;
43303 }
43304 {
43305 #if wxUSE_UNICODE
43306 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43307 #else
43308 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43309 #endif
43310 }
43311 return resultobj;
43312 fail:
43313 return NULL;
43314 }
43315
43316
43317 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43318 PyObject *resultobj = 0;
43319 wxString *arg1 = 0 ;
43320 wxString result;
43321 bool temp1 = false ;
43322 PyObject * obj0 = 0 ;
43323 char * kwnames[] = {
43324 (char *) "text", NULL
43325 };
43326
43327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43328 {
43329 arg1 = wxString_in_helper(obj0);
43330 if (arg1 == NULL) SWIG_fail;
43331 temp1 = true;
43332 }
43333 {
43334 PyThreadState* __tstate = wxPyBeginAllowThreads();
43335 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43336 wxPyEndAllowThreads(__tstate);
43337 if (PyErr_Occurred()) SWIG_fail;
43338 }
43339 {
43340 #if wxUSE_UNICODE
43341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43342 #else
43343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43344 #endif
43345 }
43346 {
43347 if (temp1)
43348 delete arg1;
43349 }
43350 return resultobj;
43351 fail:
43352 {
43353 if (temp1)
43354 delete arg1;
43355 }
43356 return NULL;
43357 }
43358
43359
43360 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43361 PyObject *resultobj = 0;
43362 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43363 wxItemKind result;
43364 void *argp1 = 0 ;
43365 int res1 = 0 ;
43366 PyObject *swig_obj[1] ;
43367
43368 if (!args) SWIG_fail;
43369 swig_obj[0] = args;
43370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43371 if (!SWIG_IsOK(res1)) {
43372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43373 }
43374 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43375 {
43376 PyThreadState* __tstate = wxPyBeginAllowThreads();
43377 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43378 wxPyEndAllowThreads(__tstate);
43379 if (PyErr_Occurred()) SWIG_fail;
43380 }
43381 resultobj = SWIG_From_int(static_cast< int >(result));
43382 return resultobj;
43383 fail:
43384 return NULL;
43385 }
43386
43387
43388 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43389 PyObject *resultobj = 0;
43390 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43391 wxItemKind arg2 ;
43392 void *argp1 = 0 ;
43393 int res1 = 0 ;
43394 int val2 ;
43395 int ecode2 = 0 ;
43396 PyObject * obj0 = 0 ;
43397 PyObject * obj1 = 0 ;
43398 char * kwnames[] = {
43399 (char *) "self",(char *) "kind", NULL
43400 };
43401
43402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43404 if (!SWIG_IsOK(res1)) {
43405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43406 }
43407 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43408 ecode2 = SWIG_AsVal_int(obj1, &val2);
43409 if (!SWIG_IsOK(ecode2)) {
43410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43411 }
43412 arg2 = static_cast< wxItemKind >(val2);
43413 {
43414 PyThreadState* __tstate = wxPyBeginAllowThreads();
43415 (arg1)->SetKind(arg2);
43416 wxPyEndAllowThreads(__tstate);
43417 if (PyErr_Occurred()) SWIG_fail;
43418 }
43419 resultobj = SWIG_Py_Void();
43420 return resultobj;
43421 fail:
43422 return NULL;
43423 }
43424
43425
43426 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43427 PyObject *resultobj = 0;
43428 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43429 bool arg2 ;
43430 void *argp1 = 0 ;
43431 int res1 = 0 ;
43432 bool val2 ;
43433 int ecode2 = 0 ;
43434 PyObject * obj0 = 0 ;
43435 PyObject * obj1 = 0 ;
43436 char * kwnames[] = {
43437 (char *) "self",(char *) "checkable", NULL
43438 };
43439
43440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43442 if (!SWIG_IsOK(res1)) {
43443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43444 }
43445 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43446 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43447 if (!SWIG_IsOK(ecode2)) {
43448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43449 }
43450 arg2 = static_cast< bool >(val2);
43451 {
43452 PyThreadState* __tstate = wxPyBeginAllowThreads();
43453 (arg1)->SetCheckable(arg2);
43454 wxPyEndAllowThreads(__tstate);
43455 if (PyErr_Occurred()) SWIG_fail;
43456 }
43457 resultobj = SWIG_Py_Void();
43458 return resultobj;
43459 fail:
43460 return NULL;
43461 }
43462
43463
43464 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43465 PyObject *resultobj = 0;
43466 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43467 bool result;
43468 void *argp1 = 0 ;
43469 int res1 = 0 ;
43470 PyObject *swig_obj[1] ;
43471
43472 if (!args) SWIG_fail;
43473 swig_obj[0] = args;
43474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43475 if (!SWIG_IsOK(res1)) {
43476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43477 }
43478 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43479 {
43480 PyThreadState* __tstate = wxPyBeginAllowThreads();
43481 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43482 wxPyEndAllowThreads(__tstate);
43483 if (PyErr_Occurred()) SWIG_fail;
43484 }
43485 {
43486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43487 }
43488 return resultobj;
43489 fail:
43490 return NULL;
43491 }
43492
43493
43494 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43495 PyObject *resultobj = 0;
43496 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43497 bool result;
43498 void *argp1 = 0 ;
43499 int res1 = 0 ;
43500 PyObject *swig_obj[1] ;
43501
43502 if (!args) SWIG_fail;
43503 swig_obj[0] = args;
43504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43505 if (!SWIG_IsOK(res1)) {
43506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43507 }
43508 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43509 {
43510 PyThreadState* __tstate = wxPyBeginAllowThreads();
43511 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43512 wxPyEndAllowThreads(__tstate);
43513 if (PyErr_Occurred()) SWIG_fail;
43514 }
43515 {
43516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43517 }
43518 return resultobj;
43519 fail:
43520 return NULL;
43521 }
43522
43523
43524 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43525 PyObject *resultobj = 0;
43526 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43527 wxMenu *arg2 = (wxMenu *) 0 ;
43528 void *argp1 = 0 ;
43529 int res1 = 0 ;
43530 void *argp2 = 0 ;
43531 int res2 = 0 ;
43532 PyObject * obj0 = 0 ;
43533 PyObject * obj1 = 0 ;
43534 char * kwnames[] = {
43535 (char *) "self",(char *) "menu", NULL
43536 };
43537
43538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43540 if (!SWIG_IsOK(res1)) {
43541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43542 }
43543 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43544 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43545 if (!SWIG_IsOK(res2)) {
43546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43547 }
43548 arg2 = reinterpret_cast< wxMenu * >(argp2);
43549 {
43550 PyThreadState* __tstate = wxPyBeginAllowThreads();
43551 (arg1)->SetSubMenu(arg2);
43552 wxPyEndAllowThreads(__tstate);
43553 if (PyErr_Occurred()) SWIG_fail;
43554 }
43555 resultobj = SWIG_Py_Void();
43556 return resultobj;
43557 fail:
43558 return NULL;
43559 }
43560
43561
43562 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43563 PyObject *resultobj = 0;
43564 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43565 wxMenu *result = 0 ;
43566 void *argp1 = 0 ;
43567 int res1 = 0 ;
43568 PyObject *swig_obj[1] ;
43569
43570 if (!args) SWIG_fail;
43571 swig_obj[0] = args;
43572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43573 if (!SWIG_IsOK(res1)) {
43574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43575 }
43576 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43577 {
43578 PyThreadState* __tstate = wxPyBeginAllowThreads();
43579 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43580 wxPyEndAllowThreads(__tstate);
43581 if (PyErr_Occurred()) SWIG_fail;
43582 }
43583 {
43584 resultobj = wxPyMake_wxObject(result, 0);
43585 }
43586 return resultobj;
43587 fail:
43588 return NULL;
43589 }
43590
43591
43592 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43593 PyObject *resultobj = 0;
43594 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43595 bool arg2 = (bool) true ;
43596 void *argp1 = 0 ;
43597 int res1 = 0 ;
43598 bool val2 ;
43599 int ecode2 = 0 ;
43600 PyObject * obj0 = 0 ;
43601 PyObject * obj1 = 0 ;
43602 char * kwnames[] = {
43603 (char *) "self",(char *) "enable", NULL
43604 };
43605
43606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43608 if (!SWIG_IsOK(res1)) {
43609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43610 }
43611 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43612 if (obj1) {
43613 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43614 if (!SWIG_IsOK(ecode2)) {
43615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43616 }
43617 arg2 = static_cast< bool >(val2);
43618 }
43619 {
43620 PyThreadState* __tstate = wxPyBeginAllowThreads();
43621 (arg1)->Enable(arg2);
43622 wxPyEndAllowThreads(__tstate);
43623 if (PyErr_Occurred()) SWIG_fail;
43624 }
43625 resultobj = SWIG_Py_Void();
43626 return resultobj;
43627 fail:
43628 return NULL;
43629 }
43630
43631
43632 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43633 PyObject *resultobj = 0;
43634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43635 bool result;
43636 void *argp1 = 0 ;
43637 int res1 = 0 ;
43638 PyObject *swig_obj[1] ;
43639
43640 if (!args) SWIG_fail;
43641 swig_obj[0] = args;
43642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43643 if (!SWIG_IsOK(res1)) {
43644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43645 }
43646 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43647 {
43648 PyThreadState* __tstate = wxPyBeginAllowThreads();
43649 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43650 wxPyEndAllowThreads(__tstate);
43651 if (PyErr_Occurred()) SWIG_fail;
43652 }
43653 {
43654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43655 }
43656 return resultobj;
43657 fail:
43658 return NULL;
43659 }
43660
43661
43662 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43663 PyObject *resultobj = 0;
43664 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43665 bool arg2 = (bool) true ;
43666 void *argp1 = 0 ;
43667 int res1 = 0 ;
43668 bool val2 ;
43669 int ecode2 = 0 ;
43670 PyObject * obj0 = 0 ;
43671 PyObject * obj1 = 0 ;
43672 char * kwnames[] = {
43673 (char *) "self",(char *) "check", NULL
43674 };
43675
43676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43678 if (!SWIG_IsOK(res1)) {
43679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43680 }
43681 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43682 if (obj1) {
43683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43684 if (!SWIG_IsOK(ecode2)) {
43685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43686 }
43687 arg2 = static_cast< bool >(val2);
43688 }
43689 {
43690 PyThreadState* __tstate = wxPyBeginAllowThreads();
43691 (arg1)->Check(arg2);
43692 wxPyEndAllowThreads(__tstate);
43693 if (PyErr_Occurred()) SWIG_fail;
43694 }
43695 resultobj = SWIG_Py_Void();
43696 return resultobj;
43697 fail:
43698 return NULL;
43699 }
43700
43701
43702 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43703 PyObject *resultobj = 0;
43704 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43705 bool result;
43706 void *argp1 = 0 ;
43707 int res1 = 0 ;
43708 PyObject *swig_obj[1] ;
43709
43710 if (!args) SWIG_fail;
43711 swig_obj[0] = args;
43712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43713 if (!SWIG_IsOK(res1)) {
43714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43715 }
43716 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43717 {
43718 PyThreadState* __tstate = wxPyBeginAllowThreads();
43719 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43720 wxPyEndAllowThreads(__tstate);
43721 if (PyErr_Occurred()) SWIG_fail;
43722 }
43723 {
43724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43725 }
43726 return resultobj;
43727 fail:
43728 return NULL;
43729 }
43730
43731
43732 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43733 PyObject *resultobj = 0;
43734 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43735 void *argp1 = 0 ;
43736 int res1 = 0 ;
43737 PyObject *swig_obj[1] ;
43738
43739 if (!args) SWIG_fail;
43740 swig_obj[0] = args;
43741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43742 if (!SWIG_IsOK(res1)) {
43743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43744 }
43745 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43746 {
43747 PyThreadState* __tstate = wxPyBeginAllowThreads();
43748 (arg1)->Toggle();
43749 wxPyEndAllowThreads(__tstate);
43750 if (PyErr_Occurred()) SWIG_fail;
43751 }
43752 resultobj = SWIG_Py_Void();
43753 return resultobj;
43754 fail:
43755 return NULL;
43756 }
43757
43758
43759 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43760 PyObject *resultobj = 0;
43761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43762 wxString *arg2 = 0 ;
43763 void *argp1 = 0 ;
43764 int res1 = 0 ;
43765 bool temp2 = false ;
43766 PyObject * obj0 = 0 ;
43767 PyObject * obj1 = 0 ;
43768 char * kwnames[] = {
43769 (char *) "self",(char *) "str", NULL
43770 };
43771
43772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43774 if (!SWIG_IsOK(res1)) {
43775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43776 }
43777 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43778 {
43779 arg2 = wxString_in_helper(obj1);
43780 if (arg2 == NULL) SWIG_fail;
43781 temp2 = true;
43782 }
43783 {
43784 PyThreadState* __tstate = wxPyBeginAllowThreads();
43785 (arg1)->SetHelp((wxString const &)*arg2);
43786 wxPyEndAllowThreads(__tstate);
43787 if (PyErr_Occurred()) SWIG_fail;
43788 }
43789 resultobj = SWIG_Py_Void();
43790 {
43791 if (temp2)
43792 delete arg2;
43793 }
43794 return resultobj;
43795 fail:
43796 {
43797 if (temp2)
43798 delete arg2;
43799 }
43800 return NULL;
43801 }
43802
43803
43804 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43805 PyObject *resultobj = 0;
43806 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43807 wxString *result = 0 ;
43808 void *argp1 = 0 ;
43809 int res1 = 0 ;
43810 PyObject *swig_obj[1] ;
43811
43812 if (!args) SWIG_fail;
43813 swig_obj[0] = args;
43814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43815 if (!SWIG_IsOK(res1)) {
43816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43817 }
43818 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43819 {
43820 PyThreadState* __tstate = wxPyBeginAllowThreads();
43821 {
43822 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43823 result = (wxString *) &_result_ref;
43824 }
43825 wxPyEndAllowThreads(__tstate);
43826 if (PyErr_Occurred()) SWIG_fail;
43827 }
43828 {
43829 #if wxUSE_UNICODE
43830 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43831 #else
43832 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43833 #endif
43834 }
43835 return resultobj;
43836 fail:
43837 return NULL;
43838 }
43839
43840
43841 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43842 PyObject *resultobj = 0;
43843 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43844 wxAcceleratorEntry *result = 0 ;
43845 void *argp1 = 0 ;
43846 int res1 = 0 ;
43847 PyObject *swig_obj[1] ;
43848
43849 if (!args) SWIG_fail;
43850 swig_obj[0] = args;
43851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43852 if (!SWIG_IsOK(res1)) {
43853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43854 }
43855 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43856 {
43857 PyThreadState* __tstate = wxPyBeginAllowThreads();
43858 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43859 wxPyEndAllowThreads(__tstate);
43860 if (PyErr_Occurred()) SWIG_fail;
43861 }
43862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43863 return resultobj;
43864 fail:
43865 return NULL;
43866 }
43867
43868
43869 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43870 PyObject *resultobj = 0;
43871 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43872 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43873 void *argp1 = 0 ;
43874 int res1 = 0 ;
43875 void *argp2 = 0 ;
43876 int res2 = 0 ;
43877 PyObject * obj0 = 0 ;
43878 PyObject * obj1 = 0 ;
43879 char * kwnames[] = {
43880 (char *) "self",(char *) "accel", NULL
43881 };
43882
43883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43885 if (!SWIG_IsOK(res1)) {
43886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43887 }
43888 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43889 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43890 if (!SWIG_IsOK(res2)) {
43891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43892 }
43893 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43894 {
43895 PyThreadState* __tstate = wxPyBeginAllowThreads();
43896 (arg1)->SetAccel(arg2);
43897 wxPyEndAllowThreads(__tstate);
43898 if (PyErr_Occurred()) SWIG_fail;
43899 }
43900 resultobj = SWIG_Py_Void();
43901 return resultobj;
43902 fail:
43903 return NULL;
43904 }
43905
43906
43907 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43908 PyObject *resultobj = 0;
43909 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43910 wxBitmap *arg2 = 0 ;
43911 void *argp1 = 0 ;
43912 int res1 = 0 ;
43913 void *argp2 = 0 ;
43914 int res2 = 0 ;
43915 PyObject * obj0 = 0 ;
43916 PyObject * obj1 = 0 ;
43917 char * kwnames[] = {
43918 (char *) "self",(char *) "bitmap", NULL
43919 };
43920
43921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43923 if (!SWIG_IsOK(res1)) {
43924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43925 }
43926 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43928 if (!SWIG_IsOK(res2)) {
43929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43930 }
43931 if (!argp2) {
43932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43933 }
43934 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43935 {
43936 PyThreadState* __tstate = wxPyBeginAllowThreads();
43937 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43938 wxPyEndAllowThreads(__tstate);
43939 if (PyErr_Occurred()) SWIG_fail;
43940 }
43941 resultobj = SWIG_Py_Void();
43942 return resultobj;
43943 fail:
43944 return NULL;
43945 }
43946
43947
43948 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43949 PyObject *resultobj = 0;
43950 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43951 wxBitmap *result = 0 ;
43952 void *argp1 = 0 ;
43953 int res1 = 0 ;
43954 PyObject *swig_obj[1] ;
43955
43956 if (!args) SWIG_fail;
43957 swig_obj[0] = args;
43958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43959 if (!SWIG_IsOK(res1)) {
43960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43961 }
43962 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43963 {
43964 PyThreadState* __tstate = wxPyBeginAllowThreads();
43965 {
43966 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43967 result = (wxBitmap *) &_result_ref;
43968 }
43969 wxPyEndAllowThreads(__tstate);
43970 if (PyErr_Occurred()) SWIG_fail;
43971 }
43972 {
43973 wxBitmap* resultptr = new wxBitmap(*result);
43974 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43975 }
43976 return resultobj;
43977 fail:
43978 return NULL;
43979 }
43980
43981
43982 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43983 PyObject *resultobj = 0;
43984 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43985 wxFont *arg2 = 0 ;
43986 void *argp1 = 0 ;
43987 int res1 = 0 ;
43988 void *argp2 = 0 ;
43989 int res2 = 0 ;
43990 PyObject * obj0 = 0 ;
43991 PyObject * obj1 = 0 ;
43992 char * kwnames[] = {
43993 (char *) "self",(char *) "font", NULL
43994 };
43995
43996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43998 if (!SWIG_IsOK(res1)) {
43999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44000 }
44001 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44002 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44003 if (!SWIG_IsOK(res2)) {
44004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44005 }
44006 if (!argp2) {
44007 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44008 }
44009 arg2 = reinterpret_cast< wxFont * >(argp2);
44010 {
44011 PyThreadState* __tstate = wxPyBeginAllowThreads();
44012 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44013 wxPyEndAllowThreads(__tstate);
44014 if (PyErr_Occurred()) SWIG_fail;
44015 }
44016 resultobj = SWIG_Py_Void();
44017 return resultobj;
44018 fail:
44019 return NULL;
44020 }
44021
44022
44023 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44024 PyObject *resultobj = 0;
44025 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44026 wxFont result;
44027 void *argp1 = 0 ;
44028 int res1 = 0 ;
44029 PyObject *swig_obj[1] ;
44030
44031 if (!args) SWIG_fail;
44032 swig_obj[0] = args;
44033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44034 if (!SWIG_IsOK(res1)) {
44035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44036 }
44037 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44038 {
44039 PyThreadState* __tstate = wxPyBeginAllowThreads();
44040 result = wxMenuItem_GetFont(arg1);
44041 wxPyEndAllowThreads(__tstate);
44042 if (PyErr_Occurred()) SWIG_fail;
44043 }
44044 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44045 return resultobj;
44046 fail:
44047 return NULL;
44048 }
44049
44050
44051 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44052 PyObject *resultobj = 0;
44053 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44054 wxColour *arg2 = 0 ;
44055 void *argp1 = 0 ;
44056 int res1 = 0 ;
44057 wxColour temp2 ;
44058 PyObject * obj0 = 0 ;
44059 PyObject * obj1 = 0 ;
44060 char * kwnames[] = {
44061 (char *) "self",(char *) "colText", NULL
44062 };
44063
44064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44066 if (!SWIG_IsOK(res1)) {
44067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44068 }
44069 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44070 {
44071 arg2 = &temp2;
44072 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44073 }
44074 {
44075 PyThreadState* __tstate = wxPyBeginAllowThreads();
44076 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44077 wxPyEndAllowThreads(__tstate);
44078 if (PyErr_Occurred()) SWIG_fail;
44079 }
44080 resultobj = SWIG_Py_Void();
44081 return resultobj;
44082 fail:
44083 return NULL;
44084 }
44085
44086
44087 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44088 PyObject *resultobj = 0;
44089 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44090 wxColour result;
44091 void *argp1 = 0 ;
44092 int res1 = 0 ;
44093 PyObject *swig_obj[1] ;
44094
44095 if (!args) SWIG_fail;
44096 swig_obj[0] = args;
44097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44098 if (!SWIG_IsOK(res1)) {
44099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44100 }
44101 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44102 {
44103 PyThreadState* __tstate = wxPyBeginAllowThreads();
44104 result = wxMenuItem_GetTextColour(arg1);
44105 wxPyEndAllowThreads(__tstate);
44106 if (PyErr_Occurred()) SWIG_fail;
44107 }
44108 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44109 return resultobj;
44110 fail:
44111 return NULL;
44112 }
44113
44114
44115 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44116 PyObject *resultobj = 0;
44117 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44118 wxColour *arg2 = 0 ;
44119 void *argp1 = 0 ;
44120 int res1 = 0 ;
44121 wxColour temp2 ;
44122 PyObject * obj0 = 0 ;
44123 PyObject * obj1 = 0 ;
44124 char * kwnames[] = {
44125 (char *) "self",(char *) "colBack", NULL
44126 };
44127
44128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44130 if (!SWIG_IsOK(res1)) {
44131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44132 }
44133 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44134 {
44135 arg2 = &temp2;
44136 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44137 }
44138 {
44139 PyThreadState* __tstate = wxPyBeginAllowThreads();
44140 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44141 wxPyEndAllowThreads(__tstate);
44142 if (PyErr_Occurred()) SWIG_fail;
44143 }
44144 resultobj = SWIG_Py_Void();
44145 return resultobj;
44146 fail:
44147 return NULL;
44148 }
44149
44150
44151 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44152 PyObject *resultobj = 0;
44153 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44154 wxColour result;
44155 void *argp1 = 0 ;
44156 int res1 = 0 ;
44157 PyObject *swig_obj[1] ;
44158
44159 if (!args) SWIG_fail;
44160 swig_obj[0] = args;
44161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44162 if (!SWIG_IsOK(res1)) {
44163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44164 }
44165 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44166 {
44167 PyThreadState* __tstate = wxPyBeginAllowThreads();
44168 result = wxMenuItem_GetBackgroundColour(arg1);
44169 wxPyEndAllowThreads(__tstate);
44170 if (PyErr_Occurred()) SWIG_fail;
44171 }
44172 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44173 return resultobj;
44174 fail:
44175 return NULL;
44176 }
44177
44178
44179 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44180 PyObject *resultobj = 0;
44181 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44182 wxBitmap *arg2 = 0 ;
44183 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44184 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44185 void *argp1 = 0 ;
44186 int res1 = 0 ;
44187 void *argp2 = 0 ;
44188 int res2 = 0 ;
44189 void *argp3 = 0 ;
44190 int res3 = 0 ;
44191 PyObject * obj0 = 0 ;
44192 PyObject * obj1 = 0 ;
44193 PyObject * obj2 = 0 ;
44194 char * kwnames[] = {
44195 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44196 };
44197
44198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44200 if (!SWIG_IsOK(res1)) {
44201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44202 }
44203 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44205 if (!SWIG_IsOK(res2)) {
44206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44207 }
44208 if (!argp2) {
44209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44210 }
44211 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44212 if (obj2) {
44213 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44214 if (!SWIG_IsOK(res3)) {
44215 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44216 }
44217 if (!argp3) {
44218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44219 }
44220 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44221 }
44222 {
44223 PyThreadState* __tstate = wxPyBeginAllowThreads();
44224 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44225 wxPyEndAllowThreads(__tstate);
44226 if (PyErr_Occurred()) SWIG_fail;
44227 }
44228 resultobj = SWIG_Py_Void();
44229 return resultobj;
44230 fail:
44231 return NULL;
44232 }
44233
44234
44235 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44236 PyObject *resultobj = 0;
44237 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44238 wxBitmap *arg2 = 0 ;
44239 void *argp1 = 0 ;
44240 int res1 = 0 ;
44241 void *argp2 = 0 ;
44242 int res2 = 0 ;
44243 PyObject * obj0 = 0 ;
44244 PyObject * obj1 = 0 ;
44245 char * kwnames[] = {
44246 (char *) "self",(char *) "bmpDisabled", NULL
44247 };
44248
44249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44251 if (!SWIG_IsOK(res1)) {
44252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44253 }
44254 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44255 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44256 if (!SWIG_IsOK(res2)) {
44257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44258 }
44259 if (!argp2) {
44260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44261 }
44262 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44263 {
44264 PyThreadState* __tstate = wxPyBeginAllowThreads();
44265 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44266 wxPyEndAllowThreads(__tstate);
44267 if (PyErr_Occurred()) SWIG_fail;
44268 }
44269 resultobj = SWIG_Py_Void();
44270 return resultobj;
44271 fail:
44272 return NULL;
44273 }
44274
44275
44276 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44277 PyObject *resultobj = 0;
44278 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44279 wxBitmap *result = 0 ;
44280 void *argp1 = 0 ;
44281 int res1 = 0 ;
44282 PyObject *swig_obj[1] ;
44283
44284 if (!args) SWIG_fail;
44285 swig_obj[0] = args;
44286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44287 if (!SWIG_IsOK(res1)) {
44288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44289 }
44290 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44291 {
44292 PyThreadState* __tstate = wxPyBeginAllowThreads();
44293 {
44294 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44295 result = (wxBitmap *) &_result_ref;
44296 }
44297 wxPyEndAllowThreads(__tstate);
44298 if (PyErr_Occurred()) SWIG_fail;
44299 }
44300 {
44301 wxBitmap* resultptr = new wxBitmap(*result);
44302 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44303 }
44304 return resultobj;
44305 fail:
44306 return NULL;
44307 }
44308
44309
44310 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44311 PyObject *resultobj = 0;
44312 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44313 int arg2 ;
44314 void *argp1 = 0 ;
44315 int res1 = 0 ;
44316 int val2 ;
44317 int ecode2 = 0 ;
44318 PyObject * obj0 = 0 ;
44319 PyObject * obj1 = 0 ;
44320 char * kwnames[] = {
44321 (char *) "self",(char *) "nWidth", NULL
44322 };
44323
44324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44326 if (!SWIG_IsOK(res1)) {
44327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44328 }
44329 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44330 ecode2 = SWIG_AsVal_int(obj1, &val2);
44331 if (!SWIG_IsOK(ecode2)) {
44332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44333 }
44334 arg2 = static_cast< int >(val2);
44335 {
44336 PyThreadState* __tstate = wxPyBeginAllowThreads();
44337 wxMenuItem_SetMarginWidth(arg1,arg2);
44338 wxPyEndAllowThreads(__tstate);
44339 if (PyErr_Occurred()) SWIG_fail;
44340 }
44341 resultobj = SWIG_Py_Void();
44342 return resultobj;
44343 fail:
44344 return NULL;
44345 }
44346
44347
44348 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44349 PyObject *resultobj = 0;
44350 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44351 int result;
44352 void *argp1 = 0 ;
44353 int res1 = 0 ;
44354 PyObject *swig_obj[1] ;
44355
44356 if (!args) SWIG_fail;
44357 swig_obj[0] = args;
44358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44359 if (!SWIG_IsOK(res1)) {
44360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44361 }
44362 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44363 {
44364 PyThreadState* __tstate = wxPyBeginAllowThreads();
44365 result = (int)wxMenuItem_GetMarginWidth(arg1);
44366 wxPyEndAllowThreads(__tstate);
44367 if (PyErr_Occurred()) SWIG_fail;
44368 }
44369 resultobj = SWIG_From_int(static_cast< int >(result));
44370 return resultobj;
44371 fail:
44372 return NULL;
44373 }
44374
44375
44376 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44377 PyObject *resultobj = 0;
44378 int result;
44379
44380 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44381 {
44382 PyThreadState* __tstate = wxPyBeginAllowThreads();
44383 result = (int)wxMenuItem_GetDefaultMarginWidth();
44384 wxPyEndAllowThreads(__tstate);
44385 if (PyErr_Occurred()) SWIG_fail;
44386 }
44387 resultobj = SWIG_From_int(static_cast< int >(result));
44388 return resultobj;
44389 fail:
44390 return NULL;
44391 }
44392
44393
44394 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44395 PyObject *resultobj = 0;
44396 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44397 bool result;
44398 void *argp1 = 0 ;
44399 int res1 = 0 ;
44400 PyObject *swig_obj[1] ;
44401
44402 if (!args) SWIG_fail;
44403 swig_obj[0] = args;
44404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44405 if (!SWIG_IsOK(res1)) {
44406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44407 }
44408 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44409 {
44410 PyThreadState* __tstate = wxPyBeginAllowThreads();
44411 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44412 wxPyEndAllowThreads(__tstate);
44413 if (PyErr_Occurred()) SWIG_fail;
44414 }
44415 {
44416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44417 }
44418 return resultobj;
44419 fail:
44420 return NULL;
44421 }
44422
44423
44424 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44425 PyObject *resultobj = 0;
44426 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44427 bool arg2 = (bool) true ;
44428 void *argp1 = 0 ;
44429 int res1 = 0 ;
44430 bool val2 ;
44431 int ecode2 = 0 ;
44432 PyObject * obj0 = 0 ;
44433 PyObject * obj1 = 0 ;
44434 char * kwnames[] = {
44435 (char *) "self",(char *) "ownerDrawn", NULL
44436 };
44437
44438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44440 if (!SWIG_IsOK(res1)) {
44441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44442 }
44443 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44444 if (obj1) {
44445 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44446 if (!SWIG_IsOK(ecode2)) {
44447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44448 }
44449 arg2 = static_cast< bool >(val2);
44450 }
44451 {
44452 PyThreadState* __tstate = wxPyBeginAllowThreads();
44453 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44454 wxPyEndAllowThreads(__tstate);
44455 if (PyErr_Occurred()) SWIG_fail;
44456 }
44457 resultobj = SWIG_Py_Void();
44458 return resultobj;
44459 fail:
44460 return NULL;
44461 }
44462
44463
44464 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44465 PyObject *resultobj = 0;
44466 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44467 void *argp1 = 0 ;
44468 int res1 = 0 ;
44469 PyObject *swig_obj[1] ;
44470
44471 if (!args) SWIG_fail;
44472 swig_obj[0] = args;
44473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44474 if (!SWIG_IsOK(res1)) {
44475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44476 }
44477 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44478 {
44479 PyThreadState* __tstate = wxPyBeginAllowThreads();
44480 wxMenuItem_ResetOwnerDrawn(arg1);
44481 wxPyEndAllowThreads(__tstate);
44482 if (PyErr_Occurred()) SWIG_fail;
44483 }
44484 resultobj = SWIG_Py_Void();
44485 return resultobj;
44486 fail:
44487 return NULL;
44488 }
44489
44490
44491 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44492 PyObject *obj;
44493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44494 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44495 return SWIG_Py_Void();
44496 }
44497
44498 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44499 return SWIG_Python_InitShadowInstance(args);
44500 }
44501
44502 SWIGINTERN int ControlNameStr_set(PyObject *) {
44503 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44504 return 1;
44505 }
44506
44507
44508 SWIGINTERN PyObject *ControlNameStr_get(void) {
44509 PyObject *pyobj = 0;
44510
44511 {
44512 #if wxUSE_UNICODE
44513 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44514 #else
44515 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44516 #endif
44517 }
44518 return pyobj;
44519 }
44520
44521
44522 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44523 PyObject *resultobj = 0;
44524 wxWindow *arg1 = (wxWindow *) 0 ;
44525 int arg2 = (int) -1 ;
44526 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44527 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44528 wxSize const &arg4_defvalue = wxDefaultSize ;
44529 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44530 long arg5 = (long) 0 ;
44531 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44532 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44533 wxString const &arg7_defvalue = wxPyControlNameStr ;
44534 wxString *arg7 = (wxString *) &arg7_defvalue ;
44535 wxControl *result = 0 ;
44536 void *argp1 = 0 ;
44537 int res1 = 0 ;
44538 int val2 ;
44539 int ecode2 = 0 ;
44540 wxPoint temp3 ;
44541 wxSize temp4 ;
44542 long val5 ;
44543 int ecode5 = 0 ;
44544 void *argp6 = 0 ;
44545 int res6 = 0 ;
44546 bool temp7 = false ;
44547 PyObject * obj0 = 0 ;
44548 PyObject * obj1 = 0 ;
44549 PyObject * obj2 = 0 ;
44550 PyObject * obj3 = 0 ;
44551 PyObject * obj4 = 0 ;
44552 PyObject * obj5 = 0 ;
44553 PyObject * obj6 = 0 ;
44554 char * kwnames[] = {
44555 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44556 };
44557
44558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44560 if (!SWIG_IsOK(res1)) {
44561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44562 }
44563 arg1 = reinterpret_cast< wxWindow * >(argp1);
44564 if (obj1) {
44565 ecode2 = SWIG_AsVal_int(obj1, &val2);
44566 if (!SWIG_IsOK(ecode2)) {
44567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44568 }
44569 arg2 = static_cast< int >(val2);
44570 }
44571 if (obj2) {
44572 {
44573 arg3 = &temp3;
44574 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44575 }
44576 }
44577 if (obj3) {
44578 {
44579 arg4 = &temp4;
44580 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44581 }
44582 }
44583 if (obj4) {
44584 ecode5 = SWIG_AsVal_long(obj4, &val5);
44585 if (!SWIG_IsOK(ecode5)) {
44586 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44587 }
44588 arg5 = static_cast< long >(val5);
44589 }
44590 if (obj5) {
44591 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44592 if (!SWIG_IsOK(res6)) {
44593 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44594 }
44595 if (!argp6) {
44596 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44597 }
44598 arg6 = reinterpret_cast< wxValidator * >(argp6);
44599 }
44600 if (obj6) {
44601 {
44602 arg7 = wxString_in_helper(obj6);
44603 if (arg7 == NULL) SWIG_fail;
44604 temp7 = true;
44605 }
44606 }
44607 {
44608 if (!wxPyCheckForApp()) SWIG_fail;
44609 PyThreadState* __tstate = wxPyBeginAllowThreads();
44610 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44611 wxPyEndAllowThreads(__tstate);
44612 if (PyErr_Occurred()) SWIG_fail;
44613 }
44614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44615 {
44616 if (temp7)
44617 delete arg7;
44618 }
44619 return resultobj;
44620 fail:
44621 {
44622 if (temp7)
44623 delete arg7;
44624 }
44625 return NULL;
44626 }
44627
44628
44629 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44630 PyObject *resultobj = 0;
44631 wxControl *result = 0 ;
44632
44633 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44634 {
44635 if (!wxPyCheckForApp()) SWIG_fail;
44636 PyThreadState* __tstate = wxPyBeginAllowThreads();
44637 result = (wxControl *)new wxControl();
44638 wxPyEndAllowThreads(__tstate);
44639 if (PyErr_Occurred()) SWIG_fail;
44640 }
44641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44642 return resultobj;
44643 fail:
44644 return NULL;
44645 }
44646
44647
44648 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44649 PyObject *resultobj = 0;
44650 wxControl *arg1 = (wxControl *) 0 ;
44651 wxWindow *arg2 = (wxWindow *) 0 ;
44652 int arg3 = (int) -1 ;
44653 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44654 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44655 wxSize const &arg5_defvalue = wxDefaultSize ;
44656 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44657 long arg6 = (long) 0 ;
44658 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44659 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44660 wxString const &arg8_defvalue = wxPyControlNameStr ;
44661 wxString *arg8 = (wxString *) &arg8_defvalue ;
44662 bool result;
44663 void *argp1 = 0 ;
44664 int res1 = 0 ;
44665 void *argp2 = 0 ;
44666 int res2 = 0 ;
44667 int val3 ;
44668 int ecode3 = 0 ;
44669 wxPoint temp4 ;
44670 wxSize temp5 ;
44671 long val6 ;
44672 int ecode6 = 0 ;
44673 void *argp7 = 0 ;
44674 int res7 = 0 ;
44675 bool temp8 = false ;
44676 PyObject * obj0 = 0 ;
44677 PyObject * obj1 = 0 ;
44678 PyObject * obj2 = 0 ;
44679 PyObject * obj3 = 0 ;
44680 PyObject * obj4 = 0 ;
44681 PyObject * obj5 = 0 ;
44682 PyObject * obj6 = 0 ;
44683 PyObject * obj7 = 0 ;
44684 char * kwnames[] = {
44685 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44686 };
44687
44688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44690 if (!SWIG_IsOK(res1)) {
44691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44692 }
44693 arg1 = reinterpret_cast< wxControl * >(argp1);
44694 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44695 if (!SWIG_IsOK(res2)) {
44696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44697 }
44698 arg2 = reinterpret_cast< wxWindow * >(argp2);
44699 if (obj2) {
44700 ecode3 = SWIG_AsVal_int(obj2, &val3);
44701 if (!SWIG_IsOK(ecode3)) {
44702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44703 }
44704 arg3 = static_cast< int >(val3);
44705 }
44706 if (obj3) {
44707 {
44708 arg4 = &temp4;
44709 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44710 }
44711 }
44712 if (obj4) {
44713 {
44714 arg5 = &temp5;
44715 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44716 }
44717 }
44718 if (obj5) {
44719 ecode6 = SWIG_AsVal_long(obj5, &val6);
44720 if (!SWIG_IsOK(ecode6)) {
44721 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44722 }
44723 arg6 = static_cast< long >(val6);
44724 }
44725 if (obj6) {
44726 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44727 if (!SWIG_IsOK(res7)) {
44728 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44729 }
44730 if (!argp7) {
44731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44732 }
44733 arg7 = reinterpret_cast< wxValidator * >(argp7);
44734 }
44735 if (obj7) {
44736 {
44737 arg8 = wxString_in_helper(obj7);
44738 if (arg8 == NULL) SWIG_fail;
44739 temp8 = true;
44740 }
44741 }
44742 {
44743 PyThreadState* __tstate = wxPyBeginAllowThreads();
44744 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44745 wxPyEndAllowThreads(__tstate);
44746 if (PyErr_Occurred()) SWIG_fail;
44747 }
44748 {
44749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44750 }
44751 {
44752 if (temp8)
44753 delete arg8;
44754 }
44755 return resultobj;
44756 fail:
44757 {
44758 if (temp8)
44759 delete arg8;
44760 }
44761 return NULL;
44762 }
44763
44764
44765 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44766 PyObject *resultobj = 0;
44767 wxControl *arg1 = (wxControl *) 0 ;
44768 int result;
44769 void *argp1 = 0 ;
44770 int res1 = 0 ;
44771 PyObject *swig_obj[1] ;
44772
44773 if (!args) SWIG_fail;
44774 swig_obj[0] = args;
44775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44776 if (!SWIG_IsOK(res1)) {
44777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44778 }
44779 arg1 = reinterpret_cast< wxControl * >(argp1);
44780 {
44781 PyThreadState* __tstate = wxPyBeginAllowThreads();
44782 result = (int)((wxControl const *)arg1)->GetAlignment();
44783 wxPyEndAllowThreads(__tstate);
44784 if (PyErr_Occurred()) SWIG_fail;
44785 }
44786 resultobj = SWIG_From_int(static_cast< int >(result));
44787 return resultobj;
44788 fail:
44789 return NULL;
44790 }
44791
44792
44793 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44794 PyObject *resultobj = 0;
44795 wxControl *arg1 = (wxControl *) 0 ;
44796 wxString result;
44797 void *argp1 = 0 ;
44798 int res1 = 0 ;
44799 PyObject *swig_obj[1] ;
44800
44801 if (!args) SWIG_fail;
44802 swig_obj[0] = args;
44803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44804 if (!SWIG_IsOK(res1)) {
44805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44806 }
44807 arg1 = reinterpret_cast< wxControl * >(argp1);
44808 {
44809 PyThreadState* __tstate = wxPyBeginAllowThreads();
44810 result = ((wxControl const *)arg1)->GetLabelText();
44811 wxPyEndAllowThreads(__tstate);
44812 if (PyErr_Occurred()) SWIG_fail;
44813 }
44814 {
44815 #if wxUSE_UNICODE
44816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44817 #else
44818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44819 #endif
44820 }
44821 return resultobj;
44822 fail:
44823 return NULL;
44824 }
44825
44826
44827 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44828 PyObject *resultobj = 0;
44829 wxControl *arg1 = (wxControl *) 0 ;
44830 wxCommandEvent *arg2 = 0 ;
44831 void *argp1 = 0 ;
44832 int res1 = 0 ;
44833 void *argp2 = 0 ;
44834 int res2 = 0 ;
44835 PyObject * obj0 = 0 ;
44836 PyObject * obj1 = 0 ;
44837 char * kwnames[] = {
44838 (char *) "self",(char *) "event", NULL
44839 };
44840
44841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44843 if (!SWIG_IsOK(res1)) {
44844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44845 }
44846 arg1 = reinterpret_cast< wxControl * >(argp1);
44847 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44848 if (!SWIG_IsOK(res2)) {
44849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44850 }
44851 if (!argp2) {
44852 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44853 }
44854 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44855 {
44856 PyThreadState* __tstate = wxPyBeginAllowThreads();
44857 (arg1)->Command(*arg2);
44858 wxPyEndAllowThreads(__tstate);
44859 if (PyErr_Occurred()) SWIG_fail;
44860 }
44861 resultobj = SWIG_Py_Void();
44862 return resultobj;
44863 fail:
44864 return NULL;
44865 }
44866
44867
44868 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44869 PyObject *resultobj = 0;
44870 wxControl *arg1 = (wxControl *) 0 ;
44871 wxString result;
44872 void *argp1 = 0 ;
44873 int res1 = 0 ;
44874 PyObject *swig_obj[1] ;
44875
44876 if (!args) SWIG_fail;
44877 swig_obj[0] = args;
44878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44879 if (!SWIG_IsOK(res1)) {
44880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44881 }
44882 arg1 = reinterpret_cast< wxControl * >(argp1);
44883 {
44884 PyThreadState* __tstate = wxPyBeginAllowThreads();
44885 result = (arg1)->GetLabel();
44886 wxPyEndAllowThreads(__tstate);
44887 if (PyErr_Occurred()) SWIG_fail;
44888 }
44889 {
44890 #if wxUSE_UNICODE
44891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44892 #else
44893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44894 #endif
44895 }
44896 return resultobj;
44897 fail:
44898 return NULL;
44899 }
44900
44901
44902 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44903 PyObject *resultobj = 0;
44904 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44905 SwigValueWrapper<wxVisualAttributes > result;
44906 int val1 ;
44907 int ecode1 = 0 ;
44908 PyObject * obj0 = 0 ;
44909 char * kwnames[] = {
44910 (char *) "variant", NULL
44911 };
44912
44913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44914 if (obj0) {
44915 ecode1 = SWIG_AsVal_int(obj0, &val1);
44916 if (!SWIG_IsOK(ecode1)) {
44917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44918 }
44919 arg1 = static_cast< wxWindowVariant >(val1);
44920 }
44921 {
44922 if (!wxPyCheckForApp()) SWIG_fail;
44923 PyThreadState* __tstate = wxPyBeginAllowThreads();
44924 result = wxControl::GetClassDefaultAttributes(arg1);
44925 wxPyEndAllowThreads(__tstate);
44926 if (PyErr_Occurred()) SWIG_fail;
44927 }
44928 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44929 return resultobj;
44930 fail:
44931 return NULL;
44932 }
44933
44934
44935 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44936 PyObject *obj;
44937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44938 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44939 return SWIG_Py_Void();
44940 }
44941
44942 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44943 return SWIG_Python_InitShadowInstance(args);
44944 }
44945
44946 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44947 PyObject *resultobj = 0;
44948 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44949 wxString *arg2 = 0 ;
44950 PyObject *arg3 = (PyObject *) NULL ;
44951 int result;
44952 void *argp1 = 0 ;
44953 int res1 = 0 ;
44954 bool temp2 = false ;
44955 PyObject * obj0 = 0 ;
44956 PyObject * obj1 = 0 ;
44957 PyObject * obj2 = 0 ;
44958 char * kwnames[] = {
44959 (char *) "self",(char *) "item",(char *) "clientData", NULL
44960 };
44961
44962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44964 if (!SWIG_IsOK(res1)) {
44965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44966 }
44967 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44968 {
44969 arg2 = wxString_in_helper(obj1);
44970 if (arg2 == NULL) SWIG_fail;
44971 temp2 = true;
44972 }
44973 if (obj2) {
44974 arg3 = obj2;
44975 }
44976 {
44977 PyThreadState* __tstate = wxPyBeginAllowThreads();
44978 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44979 wxPyEndAllowThreads(__tstate);
44980 if (PyErr_Occurred()) SWIG_fail;
44981 }
44982 resultobj = SWIG_From_int(static_cast< int >(result));
44983 {
44984 if (temp2)
44985 delete arg2;
44986 }
44987 return resultobj;
44988 fail:
44989 {
44990 if (temp2)
44991 delete arg2;
44992 }
44993 return NULL;
44994 }
44995
44996
44997 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44998 PyObject *resultobj = 0;
44999 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45000 wxArrayString *arg2 = 0 ;
45001 void *argp1 = 0 ;
45002 int res1 = 0 ;
45003 bool temp2 = false ;
45004 PyObject * obj0 = 0 ;
45005 PyObject * obj1 = 0 ;
45006 char * kwnames[] = {
45007 (char *) "self",(char *) "strings", NULL
45008 };
45009
45010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45012 if (!SWIG_IsOK(res1)) {
45013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45014 }
45015 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45016 {
45017 if (! PySequence_Check(obj1)) {
45018 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45019 SWIG_fail;
45020 }
45021 arg2 = new wxArrayString;
45022 temp2 = true;
45023 int i, len=PySequence_Length(obj1);
45024 for (i=0; i<len; i++) {
45025 PyObject* item = PySequence_GetItem(obj1, i);
45026 wxString* s = wxString_in_helper(item);
45027 if (PyErr_Occurred()) SWIG_fail;
45028 arg2->Add(*s);
45029 delete s;
45030 Py_DECREF(item);
45031 }
45032 }
45033 {
45034 PyThreadState* __tstate = wxPyBeginAllowThreads();
45035 (arg1)->Append((wxArrayString const &)*arg2);
45036 wxPyEndAllowThreads(__tstate);
45037 if (PyErr_Occurred()) SWIG_fail;
45038 }
45039 resultobj = SWIG_Py_Void();
45040 {
45041 if (temp2) delete arg2;
45042 }
45043 return resultobj;
45044 fail:
45045 {
45046 if (temp2) delete arg2;
45047 }
45048 return NULL;
45049 }
45050
45051
45052 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45053 PyObject *resultobj = 0;
45054 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45055 wxString *arg2 = 0 ;
45056 unsigned int arg3 ;
45057 PyObject *arg4 = (PyObject *) NULL ;
45058 int result;
45059 void *argp1 = 0 ;
45060 int res1 = 0 ;
45061 bool temp2 = false ;
45062 unsigned int val3 ;
45063 int ecode3 = 0 ;
45064 PyObject * obj0 = 0 ;
45065 PyObject * obj1 = 0 ;
45066 PyObject * obj2 = 0 ;
45067 PyObject * obj3 = 0 ;
45068 char * kwnames[] = {
45069 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45070 };
45071
45072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45074 if (!SWIG_IsOK(res1)) {
45075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45076 }
45077 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45078 {
45079 arg2 = wxString_in_helper(obj1);
45080 if (arg2 == NULL) SWIG_fail;
45081 temp2 = true;
45082 }
45083 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45084 if (!SWIG_IsOK(ecode3)) {
45085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45086 }
45087 arg3 = static_cast< unsigned int >(val3);
45088 if (obj3) {
45089 arg4 = obj3;
45090 }
45091 {
45092 PyThreadState* __tstate = wxPyBeginAllowThreads();
45093 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45094 wxPyEndAllowThreads(__tstate);
45095 if (PyErr_Occurred()) SWIG_fail;
45096 }
45097 resultobj = SWIG_From_int(static_cast< int >(result));
45098 {
45099 if (temp2)
45100 delete arg2;
45101 }
45102 return resultobj;
45103 fail:
45104 {
45105 if (temp2)
45106 delete arg2;
45107 }
45108 return NULL;
45109 }
45110
45111
45112 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45113 PyObject *resultobj = 0;
45114 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45115 void *argp1 = 0 ;
45116 int res1 = 0 ;
45117 PyObject *swig_obj[1] ;
45118
45119 if (!args) SWIG_fail;
45120 swig_obj[0] = args;
45121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45122 if (!SWIG_IsOK(res1)) {
45123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45124 }
45125 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45126 {
45127 PyThreadState* __tstate = wxPyBeginAllowThreads();
45128 (arg1)->Clear();
45129 wxPyEndAllowThreads(__tstate);
45130 if (PyErr_Occurred()) SWIG_fail;
45131 }
45132 resultobj = SWIG_Py_Void();
45133 return resultobj;
45134 fail:
45135 return NULL;
45136 }
45137
45138
45139 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45140 PyObject *resultobj = 0;
45141 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45142 unsigned int arg2 ;
45143 void *argp1 = 0 ;
45144 int res1 = 0 ;
45145 unsigned int val2 ;
45146 int ecode2 = 0 ;
45147 PyObject * obj0 = 0 ;
45148 PyObject * obj1 = 0 ;
45149 char * kwnames[] = {
45150 (char *) "self",(char *) "n", NULL
45151 };
45152
45153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45155 if (!SWIG_IsOK(res1)) {
45156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45157 }
45158 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45159 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45160 if (!SWIG_IsOK(ecode2)) {
45161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45162 }
45163 arg2 = static_cast< unsigned int >(val2);
45164 {
45165 PyThreadState* __tstate = wxPyBeginAllowThreads();
45166 (arg1)->Delete(arg2);
45167 wxPyEndAllowThreads(__tstate);
45168 if (PyErr_Occurred()) SWIG_fail;
45169 }
45170 resultobj = SWIG_Py_Void();
45171 return resultobj;
45172 fail:
45173 return NULL;
45174 }
45175
45176
45177 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45178 PyObject *resultobj = 0;
45179 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45180 unsigned int arg2 ;
45181 PyObject *result = 0 ;
45182 void *argp1 = 0 ;
45183 int res1 = 0 ;
45184 unsigned int val2 ;
45185 int ecode2 = 0 ;
45186 PyObject * obj0 = 0 ;
45187 PyObject * obj1 = 0 ;
45188 char * kwnames[] = {
45189 (char *) "self",(char *) "n", NULL
45190 };
45191
45192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45194 if (!SWIG_IsOK(res1)) {
45195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45196 }
45197 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45198 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45199 if (!SWIG_IsOK(ecode2)) {
45200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45201 }
45202 arg2 = static_cast< unsigned int >(val2);
45203 {
45204 PyThreadState* __tstate = wxPyBeginAllowThreads();
45205 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45206 wxPyEndAllowThreads(__tstate);
45207 if (PyErr_Occurred()) SWIG_fail;
45208 }
45209 resultobj = result;
45210 return resultobj;
45211 fail:
45212 return NULL;
45213 }
45214
45215
45216 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45217 PyObject *resultobj = 0;
45218 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45219 unsigned int arg2 ;
45220 PyObject *arg3 = (PyObject *) 0 ;
45221 void *argp1 = 0 ;
45222 int res1 = 0 ;
45223 unsigned int val2 ;
45224 int ecode2 = 0 ;
45225 PyObject * obj0 = 0 ;
45226 PyObject * obj1 = 0 ;
45227 PyObject * obj2 = 0 ;
45228 char * kwnames[] = {
45229 (char *) "self",(char *) "n",(char *) "clientData", NULL
45230 };
45231
45232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45234 if (!SWIG_IsOK(res1)) {
45235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45236 }
45237 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45238 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45239 if (!SWIG_IsOK(ecode2)) {
45240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45241 }
45242 arg2 = static_cast< unsigned int >(val2);
45243 arg3 = obj2;
45244 {
45245 PyThreadState* __tstate = wxPyBeginAllowThreads();
45246 wxItemContainer_SetClientData(arg1,arg2,arg3);
45247 wxPyEndAllowThreads(__tstate);
45248 if (PyErr_Occurred()) SWIG_fail;
45249 }
45250 resultobj = SWIG_Py_Void();
45251 return resultobj;
45252 fail:
45253 return NULL;
45254 }
45255
45256
45257 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45258 PyObject *resultobj = 0;
45259 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45260 unsigned int result;
45261 void *argp1 = 0 ;
45262 int res1 = 0 ;
45263 PyObject *swig_obj[1] ;
45264
45265 if (!args) SWIG_fail;
45266 swig_obj[0] = args;
45267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45268 if (!SWIG_IsOK(res1)) {
45269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45270 }
45271 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45272 {
45273 PyThreadState* __tstate = wxPyBeginAllowThreads();
45274 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45275 wxPyEndAllowThreads(__tstate);
45276 if (PyErr_Occurred()) SWIG_fail;
45277 }
45278 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45279 return resultobj;
45280 fail:
45281 return NULL;
45282 }
45283
45284
45285 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45286 PyObject *resultobj = 0;
45287 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45288 bool result;
45289 void *argp1 = 0 ;
45290 int res1 = 0 ;
45291 PyObject *swig_obj[1] ;
45292
45293 if (!args) SWIG_fail;
45294 swig_obj[0] = args;
45295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45296 if (!SWIG_IsOK(res1)) {
45297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45298 }
45299 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45300 {
45301 PyThreadState* __tstate = wxPyBeginAllowThreads();
45302 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45303 wxPyEndAllowThreads(__tstate);
45304 if (PyErr_Occurred()) SWIG_fail;
45305 }
45306 {
45307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45308 }
45309 return resultobj;
45310 fail:
45311 return NULL;
45312 }
45313
45314
45315 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45316 PyObject *resultobj = 0;
45317 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45318 unsigned int arg2 ;
45319 wxString result;
45320 void *argp1 = 0 ;
45321 int res1 = 0 ;
45322 unsigned int val2 ;
45323 int ecode2 = 0 ;
45324 PyObject * obj0 = 0 ;
45325 PyObject * obj1 = 0 ;
45326 char * kwnames[] = {
45327 (char *) "self",(char *) "n", NULL
45328 };
45329
45330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45332 if (!SWIG_IsOK(res1)) {
45333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45334 }
45335 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45336 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45337 if (!SWIG_IsOK(ecode2)) {
45338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45339 }
45340 arg2 = static_cast< unsigned int >(val2);
45341 {
45342 PyThreadState* __tstate = wxPyBeginAllowThreads();
45343 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45344 wxPyEndAllowThreads(__tstate);
45345 if (PyErr_Occurred()) SWIG_fail;
45346 }
45347 {
45348 #if wxUSE_UNICODE
45349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45350 #else
45351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45352 #endif
45353 }
45354 return resultobj;
45355 fail:
45356 return NULL;
45357 }
45358
45359
45360 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45361 PyObject *resultobj = 0;
45362 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45363 wxArrayString result;
45364 void *argp1 = 0 ;
45365 int res1 = 0 ;
45366 PyObject *swig_obj[1] ;
45367
45368 if (!args) SWIG_fail;
45369 swig_obj[0] = args;
45370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45371 if (!SWIG_IsOK(res1)) {
45372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45373 }
45374 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45375 {
45376 PyThreadState* __tstate = wxPyBeginAllowThreads();
45377 result = ((wxItemContainer const *)arg1)->GetStrings();
45378 wxPyEndAllowThreads(__tstate);
45379 if (PyErr_Occurred()) SWIG_fail;
45380 }
45381 {
45382 resultobj = wxArrayString2PyList_helper(result);
45383 }
45384 return resultobj;
45385 fail:
45386 return NULL;
45387 }
45388
45389
45390 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45391 PyObject *resultobj = 0;
45392 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45393 unsigned int arg2 ;
45394 wxString *arg3 = 0 ;
45395 void *argp1 = 0 ;
45396 int res1 = 0 ;
45397 unsigned int val2 ;
45398 int ecode2 = 0 ;
45399 bool temp3 = false ;
45400 PyObject * obj0 = 0 ;
45401 PyObject * obj1 = 0 ;
45402 PyObject * obj2 = 0 ;
45403 char * kwnames[] = {
45404 (char *) "self",(char *) "n",(char *) "s", NULL
45405 };
45406
45407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45409 if (!SWIG_IsOK(res1)) {
45410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45411 }
45412 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45413 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45414 if (!SWIG_IsOK(ecode2)) {
45415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45416 }
45417 arg2 = static_cast< unsigned int >(val2);
45418 {
45419 arg3 = wxString_in_helper(obj2);
45420 if (arg3 == NULL) SWIG_fail;
45421 temp3 = true;
45422 }
45423 {
45424 PyThreadState* __tstate = wxPyBeginAllowThreads();
45425 (arg1)->SetString(arg2,(wxString const &)*arg3);
45426 wxPyEndAllowThreads(__tstate);
45427 if (PyErr_Occurred()) SWIG_fail;
45428 }
45429 resultobj = SWIG_Py_Void();
45430 {
45431 if (temp3)
45432 delete arg3;
45433 }
45434 return resultobj;
45435 fail:
45436 {
45437 if (temp3)
45438 delete arg3;
45439 }
45440 return NULL;
45441 }
45442
45443
45444 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45445 PyObject *resultobj = 0;
45446 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45447 wxString *arg2 = 0 ;
45448 int result;
45449 void *argp1 = 0 ;
45450 int res1 = 0 ;
45451 bool temp2 = false ;
45452 PyObject * obj0 = 0 ;
45453 PyObject * obj1 = 0 ;
45454 char * kwnames[] = {
45455 (char *) "self",(char *) "s", NULL
45456 };
45457
45458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45460 if (!SWIG_IsOK(res1)) {
45461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45462 }
45463 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45464 {
45465 arg2 = wxString_in_helper(obj1);
45466 if (arg2 == NULL) SWIG_fail;
45467 temp2 = true;
45468 }
45469 {
45470 PyThreadState* __tstate = wxPyBeginAllowThreads();
45471 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45472 wxPyEndAllowThreads(__tstate);
45473 if (PyErr_Occurred()) SWIG_fail;
45474 }
45475 resultobj = SWIG_From_int(static_cast< int >(result));
45476 {
45477 if (temp2)
45478 delete arg2;
45479 }
45480 return resultobj;
45481 fail:
45482 {
45483 if (temp2)
45484 delete arg2;
45485 }
45486 return NULL;
45487 }
45488
45489
45490 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45491 PyObject *resultobj = 0;
45492 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45493 int arg2 ;
45494 void *argp1 = 0 ;
45495 int res1 = 0 ;
45496 int val2 ;
45497 int ecode2 = 0 ;
45498 PyObject * obj0 = 0 ;
45499 PyObject * obj1 = 0 ;
45500 char * kwnames[] = {
45501 (char *) "self",(char *) "n", NULL
45502 };
45503
45504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45506 if (!SWIG_IsOK(res1)) {
45507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45508 }
45509 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45510 ecode2 = SWIG_AsVal_int(obj1, &val2);
45511 if (!SWIG_IsOK(ecode2)) {
45512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45513 }
45514 arg2 = static_cast< int >(val2);
45515 {
45516 PyThreadState* __tstate = wxPyBeginAllowThreads();
45517 (arg1)->SetSelection(arg2);
45518 wxPyEndAllowThreads(__tstate);
45519 if (PyErr_Occurred()) SWIG_fail;
45520 }
45521 resultobj = SWIG_Py_Void();
45522 return resultobj;
45523 fail:
45524 return NULL;
45525 }
45526
45527
45528 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45529 PyObject *resultobj = 0;
45530 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45531 int result;
45532 void *argp1 = 0 ;
45533 int res1 = 0 ;
45534 PyObject *swig_obj[1] ;
45535
45536 if (!args) SWIG_fail;
45537 swig_obj[0] = args;
45538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45539 if (!SWIG_IsOK(res1)) {
45540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45541 }
45542 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45543 {
45544 PyThreadState* __tstate = wxPyBeginAllowThreads();
45545 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45546 wxPyEndAllowThreads(__tstate);
45547 if (PyErr_Occurred()) SWIG_fail;
45548 }
45549 resultobj = SWIG_From_int(static_cast< int >(result));
45550 return resultobj;
45551 fail:
45552 return NULL;
45553 }
45554
45555
45556 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45557 PyObject *resultobj = 0;
45558 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45559 wxString *arg2 = 0 ;
45560 bool result;
45561 void *argp1 = 0 ;
45562 int res1 = 0 ;
45563 bool temp2 = false ;
45564 PyObject * obj0 = 0 ;
45565 PyObject * obj1 = 0 ;
45566 char * kwnames[] = {
45567 (char *) "self",(char *) "s", NULL
45568 };
45569
45570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45572 if (!SWIG_IsOK(res1)) {
45573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45574 }
45575 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45576 {
45577 arg2 = wxString_in_helper(obj1);
45578 if (arg2 == NULL) SWIG_fail;
45579 temp2 = true;
45580 }
45581 {
45582 PyThreadState* __tstate = wxPyBeginAllowThreads();
45583 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45584 wxPyEndAllowThreads(__tstate);
45585 if (PyErr_Occurred()) SWIG_fail;
45586 }
45587 {
45588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45589 }
45590 {
45591 if (temp2)
45592 delete arg2;
45593 }
45594 return resultobj;
45595 fail:
45596 {
45597 if (temp2)
45598 delete arg2;
45599 }
45600 return NULL;
45601 }
45602
45603
45604 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45605 PyObject *resultobj = 0;
45606 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45607 wxString result;
45608 void *argp1 = 0 ;
45609 int res1 = 0 ;
45610 PyObject *swig_obj[1] ;
45611
45612 if (!args) SWIG_fail;
45613 swig_obj[0] = args;
45614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45615 if (!SWIG_IsOK(res1)) {
45616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45617 }
45618 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45619 {
45620 PyThreadState* __tstate = wxPyBeginAllowThreads();
45621 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45622 wxPyEndAllowThreads(__tstate);
45623 if (PyErr_Occurred()) SWIG_fail;
45624 }
45625 {
45626 #if wxUSE_UNICODE
45627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45628 #else
45629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45630 #endif
45631 }
45632 return resultobj;
45633 fail:
45634 return NULL;
45635 }
45636
45637
45638 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45639 PyObject *resultobj = 0;
45640 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45641 int arg2 ;
45642 void *argp1 = 0 ;
45643 int res1 = 0 ;
45644 int val2 ;
45645 int ecode2 = 0 ;
45646 PyObject * obj0 = 0 ;
45647 PyObject * obj1 = 0 ;
45648 char * kwnames[] = {
45649 (char *) "self",(char *) "n", NULL
45650 };
45651
45652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45654 if (!SWIG_IsOK(res1)) {
45655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45656 }
45657 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45658 ecode2 = SWIG_AsVal_int(obj1, &val2);
45659 if (!SWIG_IsOK(ecode2)) {
45660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45661 }
45662 arg2 = static_cast< int >(val2);
45663 {
45664 PyThreadState* __tstate = wxPyBeginAllowThreads();
45665 (arg1)->Select(arg2);
45666 wxPyEndAllowThreads(__tstate);
45667 if (PyErr_Occurred()) SWIG_fail;
45668 }
45669 resultobj = SWIG_Py_Void();
45670 return resultobj;
45671 fail:
45672 return NULL;
45673 }
45674
45675
45676 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45677 PyObject *obj;
45678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45679 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45680 return SWIG_Py_Void();
45681 }
45682
45683 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45684 PyObject *obj;
45685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45686 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45687 return SWIG_Py_Void();
45688 }
45689
45690 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45691 PyObject *resultobj = 0;
45692 wxSizerItem *result = 0 ;
45693
45694 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45695 {
45696 PyThreadState* __tstate = wxPyBeginAllowThreads();
45697 result = (wxSizerItem *)new wxSizerItem();
45698 wxPyEndAllowThreads(__tstate);
45699 if (PyErr_Occurred()) SWIG_fail;
45700 }
45701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45702 return resultobj;
45703 fail:
45704 return NULL;
45705 }
45706
45707
45708 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45709 PyObject *resultobj = 0;
45710 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45711 void *argp1 = 0 ;
45712 int res1 = 0 ;
45713 PyObject *swig_obj[1] ;
45714
45715 if (!args) SWIG_fail;
45716 swig_obj[0] = args;
45717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45718 if (!SWIG_IsOK(res1)) {
45719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45720 }
45721 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45722 {
45723 PyThreadState* __tstate = wxPyBeginAllowThreads();
45724 delete arg1;
45725
45726 wxPyEndAllowThreads(__tstate);
45727 if (PyErr_Occurred()) SWIG_fail;
45728 }
45729 resultobj = SWIG_Py_Void();
45730 return resultobj;
45731 fail:
45732 return NULL;
45733 }
45734
45735
45736 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45737 PyObject *resultobj = 0;
45738 wxWindow *arg1 = (wxWindow *) 0 ;
45739 int arg2 ;
45740 int arg3 ;
45741 int arg4 ;
45742 PyObject *arg5 = (PyObject *) NULL ;
45743 wxSizerItem *result = 0 ;
45744 void *argp1 = 0 ;
45745 int res1 = 0 ;
45746 int val2 ;
45747 int ecode2 = 0 ;
45748 int val3 ;
45749 int ecode3 = 0 ;
45750 int val4 ;
45751 int ecode4 = 0 ;
45752 PyObject * obj0 = 0 ;
45753 PyObject * obj1 = 0 ;
45754 PyObject * obj2 = 0 ;
45755 PyObject * obj3 = 0 ;
45756 PyObject * obj4 = 0 ;
45757 char * kwnames[] = {
45758 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45759 };
45760
45761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45763 if (!SWIG_IsOK(res1)) {
45764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45765 }
45766 arg1 = reinterpret_cast< wxWindow * >(argp1);
45767 ecode2 = SWIG_AsVal_int(obj1, &val2);
45768 if (!SWIG_IsOK(ecode2)) {
45769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45770 }
45771 arg2 = static_cast< int >(val2);
45772 ecode3 = SWIG_AsVal_int(obj2, &val3);
45773 if (!SWIG_IsOK(ecode3)) {
45774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45775 }
45776 arg3 = static_cast< int >(val3);
45777 ecode4 = SWIG_AsVal_int(obj3, &val4);
45778 if (!SWIG_IsOK(ecode4)) {
45779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45780 }
45781 arg4 = static_cast< int >(val4);
45782 if (obj4) {
45783 arg5 = obj4;
45784 }
45785 {
45786 PyThreadState* __tstate = wxPyBeginAllowThreads();
45787 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45788 wxPyEndAllowThreads(__tstate);
45789 if (PyErr_Occurred()) SWIG_fail;
45790 }
45791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45792 return resultobj;
45793 fail:
45794 return NULL;
45795 }
45796
45797
45798 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45799 PyObject *resultobj = 0;
45800 int arg1 ;
45801 int arg2 ;
45802 int arg3 ;
45803 int arg4 ;
45804 int arg5 ;
45805 PyObject *arg6 = (PyObject *) NULL ;
45806 wxSizerItem *result = 0 ;
45807 int val1 ;
45808 int ecode1 = 0 ;
45809 int val2 ;
45810 int ecode2 = 0 ;
45811 int val3 ;
45812 int ecode3 = 0 ;
45813 int val4 ;
45814 int ecode4 = 0 ;
45815 int val5 ;
45816 int ecode5 = 0 ;
45817 PyObject * obj0 = 0 ;
45818 PyObject * obj1 = 0 ;
45819 PyObject * obj2 = 0 ;
45820 PyObject * obj3 = 0 ;
45821 PyObject * obj4 = 0 ;
45822 PyObject * obj5 = 0 ;
45823 char * kwnames[] = {
45824 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45825 };
45826
45827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45828 ecode1 = SWIG_AsVal_int(obj0, &val1);
45829 if (!SWIG_IsOK(ecode1)) {
45830 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45831 }
45832 arg1 = static_cast< int >(val1);
45833 ecode2 = SWIG_AsVal_int(obj1, &val2);
45834 if (!SWIG_IsOK(ecode2)) {
45835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45836 }
45837 arg2 = static_cast< int >(val2);
45838 ecode3 = SWIG_AsVal_int(obj2, &val3);
45839 if (!SWIG_IsOK(ecode3)) {
45840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45841 }
45842 arg3 = static_cast< int >(val3);
45843 ecode4 = SWIG_AsVal_int(obj3, &val4);
45844 if (!SWIG_IsOK(ecode4)) {
45845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45846 }
45847 arg4 = static_cast< int >(val4);
45848 ecode5 = SWIG_AsVal_int(obj4, &val5);
45849 if (!SWIG_IsOK(ecode5)) {
45850 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45851 }
45852 arg5 = static_cast< int >(val5);
45853 if (obj5) {
45854 arg6 = obj5;
45855 }
45856 {
45857 PyThreadState* __tstate = wxPyBeginAllowThreads();
45858 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45859 wxPyEndAllowThreads(__tstate);
45860 if (PyErr_Occurred()) SWIG_fail;
45861 }
45862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45863 return resultobj;
45864 fail:
45865 return NULL;
45866 }
45867
45868
45869 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45870 PyObject *resultobj = 0;
45871 wxSizer *arg1 = (wxSizer *) 0 ;
45872 int arg2 ;
45873 int arg3 ;
45874 int arg4 ;
45875 PyObject *arg5 = (PyObject *) NULL ;
45876 wxSizerItem *result = 0 ;
45877 int res1 = 0 ;
45878 int val2 ;
45879 int ecode2 = 0 ;
45880 int val3 ;
45881 int ecode3 = 0 ;
45882 int val4 ;
45883 int ecode4 = 0 ;
45884 PyObject * obj0 = 0 ;
45885 PyObject * obj1 = 0 ;
45886 PyObject * obj2 = 0 ;
45887 PyObject * obj3 = 0 ;
45888 PyObject * obj4 = 0 ;
45889 char * kwnames[] = {
45890 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45891 };
45892
45893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45894 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45895 if (!SWIG_IsOK(res1)) {
45896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45897 }
45898 ecode2 = SWIG_AsVal_int(obj1, &val2);
45899 if (!SWIG_IsOK(ecode2)) {
45900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45901 }
45902 arg2 = static_cast< int >(val2);
45903 ecode3 = SWIG_AsVal_int(obj2, &val3);
45904 if (!SWIG_IsOK(ecode3)) {
45905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45906 }
45907 arg3 = static_cast< int >(val3);
45908 ecode4 = SWIG_AsVal_int(obj3, &val4);
45909 if (!SWIG_IsOK(ecode4)) {
45910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45911 }
45912 arg4 = static_cast< int >(val4);
45913 if (obj4) {
45914 arg5 = obj4;
45915 }
45916 {
45917 PyThreadState* __tstate = wxPyBeginAllowThreads();
45918 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45919 wxPyEndAllowThreads(__tstate);
45920 if (PyErr_Occurred()) SWIG_fail;
45921 }
45922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45923 return resultobj;
45924 fail:
45925 return NULL;
45926 }
45927
45928
45929 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45930 PyObject *resultobj = 0;
45931 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45932 void *argp1 = 0 ;
45933 int res1 = 0 ;
45934 PyObject *swig_obj[1] ;
45935
45936 if (!args) SWIG_fail;
45937 swig_obj[0] = args;
45938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45939 if (!SWIG_IsOK(res1)) {
45940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45941 }
45942 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45943 {
45944 PyThreadState* __tstate = wxPyBeginAllowThreads();
45945 (arg1)->DeleteWindows();
45946 wxPyEndAllowThreads(__tstate);
45947 if (PyErr_Occurred()) SWIG_fail;
45948 }
45949 resultobj = SWIG_Py_Void();
45950 return resultobj;
45951 fail:
45952 return NULL;
45953 }
45954
45955
45956 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45957 PyObject *resultobj = 0;
45958 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45959 void *argp1 = 0 ;
45960 int res1 = 0 ;
45961 PyObject *swig_obj[1] ;
45962
45963 if (!args) SWIG_fail;
45964 swig_obj[0] = args;
45965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45966 if (!SWIG_IsOK(res1)) {
45967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45968 }
45969 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45970 {
45971 PyThreadState* __tstate = wxPyBeginAllowThreads();
45972 (arg1)->DetachSizer();
45973 wxPyEndAllowThreads(__tstate);
45974 if (PyErr_Occurred()) SWIG_fail;
45975 }
45976 resultobj = SWIG_Py_Void();
45977 return resultobj;
45978 fail:
45979 return NULL;
45980 }
45981
45982
45983 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45984 PyObject *resultobj = 0;
45985 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45986 wxSize result;
45987 void *argp1 = 0 ;
45988 int res1 = 0 ;
45989 PyObject *swig_obj[1] ;
45990
45991 if (!args) SWIG_fail;
45992 swig_obj[0] = args;
45993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45994 if (!SWIG_IsOK(res1)) {
45995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45996 }
45997 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45998 {
45999 PyThreadState* __tstate = wxPyBeginAllowThreads();
46000 result = (arg1)->GetSize();
46001 wxPyEndAllowThreads(__tstate);
46002 if (PyErr_Occurred()) SWIG_fail;
46003 }
46004 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46005 return resultobj;
46006 fail:
46007 return NULL;
46008 }
46009
46010
46011 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46012 PyObject *resultobj = 0;
46013 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46014 wxSize result;
46015 void *argp1 = 0 ;
46016 int res1 = 0 ;
46017 PyObject *swig_obj[1] ;
46018
46019 if (!args) SWIG_fail;
46020 swig_obj[0] = args;
46021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46022 if (!SWIG_IsOK(res1)) {
46023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46024 }
46025 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46026 {
46027 PyThreadState* __tstate = wxPyBeginAllowThreads();
46028 result = (arg1)->CalcMin();
46029 wxPyEndAllowThreads(__tstate);
46030 if (PyErr_Occurred()) SWIG_fail;
46031 }
46032 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46033 return resultobj;
46034 fail:
46035 return NULL;
46036 }
46037
46038
46039 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46040 PyObject *resultobj = 0;
46041 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46042 wxPoint *arg2 = 0 ;
46043 wxSize *arg3 = 0 ;
46044 void *argp1 = 0 ;
46045 int res1 = 0 ;
46046 wxPoint temp2 ;
46047 wxSize temp3 ;
46048 PyObject * obj0 = 0 ;
46049 PyObject * obj1 = 0 ;
46050 PyObject * obj2 = 0 ;
46051 char * kwnames[] = {
46052 (char *) "self",(char *) "pos",(char *) "size", NULL
46053 };
46054
46055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46057 if (!SWIG_IsOK(res1)) {
46058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46059 }
46060 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46061 {
46062 arg2 = &temp2;
46063 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46064 }
46065 {
46066 arg3 = &temp3;
46067 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46068 }
46069 {
46070 PyThreadState* __tstate = wxPyBeginAllowThreads();
46071 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46072 wxPyEndAllowThreads(__tstate);
46073 if (PyErr_Occurred()) SWIG_fail;
46074 }
46075 resultobj = SWIG_Py_Void();
46076 return resultobj;
46077 fail:
46078 return NULL;
46079 }
46080
46081
46082 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46083 PyObject *resultobj = 0;
46084 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46085 wxSize result;
46086 void *argp1 = 0 ;
46087 int res1 = 0 ;
46088 PyObject *swig_obj[1] ;
46089
46090 if (!args) SWIG_fail;
46091 swig_obj[0] = args;
46092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46093 if (!SWIG_IsOK(res1)) {
46094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46095 }
46096 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46097 {
46098 PyThreadState* __tstate = wxPyBeginAllowThreads();
46099 result = (arg1)->GetMinSize();
46100 wxPyEndAllowThreads(__tstate);
46101 if (PyErr_Occurred()) SWIG_fail;
46102 }
46103 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46104 return resultobj;
46105 fail:
46106 return NULL;
46107 }
46108
46109
46110 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46111 PyObject *resultobj = 0;
46112 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46113 wxSize result;
46114 void *argp1 = 0 ;
46115 int res1 = 0 ;
46116 PyObject *swig_obj[1] ;
46117
46118 if (!args) SWIG_fail;
46119 swig_obj[0] = args;
46120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46121 if (!SWIG_IsOK(res1)) {
46122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46123 }
46124 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46125 {
46126 PyThreadState* __tstate = wxPyBeginAllowThreads();
46127 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46128 wxPyEndAllowThreads(__tstate);
46129 if (PyErr_Occurred()) SWIG_fail;
46130 }
46131 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46132 return resultobj;
46133 fail:
46134 return NULL;
46135 }
46136
46137
46138 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46139 PyObject *resultobj = 0;
46140 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46141 int arg2 ;
46142 int arg3 ;
46143 void *argp1 = 0 ;
46144 int res1 = 0 ;
46145 int val2 ;
46146 int ecode2 = 0 ;
46147 int val3 ;
46148 int ecode3 = 0 ;
46149 PyObject * obj0 = 0 ;
46150 PyObject * obj1 = 0 ;
46151 PyObject * obj2 = 0 ;
46152 char * kwnames[] = {
46153 (char *) "self",(char *) "x",(char *) "y", NULL
46154 };
46155
46156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46158 if (!SWIG_IsOK(res1)) {
46159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46160 }
46161 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46162 ecode2 = SWIG_AsVal_int(obj1, &val2);
46163 if (!SWIG_IsOK(ecode2)) {
46164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46165 }
46166 arg2 = static_cast< int >(val2);
46167 ecode3 = SWIG_AsVal_int(obj2, &val3);
46168 if (!SWIG_IsOK(ecode3)) {
46169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46170 }
46171 arg3 = static_cast< int >(val3);
46172 {
46173 PyThreadState* __tstate = wxPyBeginAllowThreads();
46174 (arg1)->SetInitSize(arg2,arg3);
46175 wxPyEndAllowThreads(__tstate);
46176 if (PyErr_Occurred()) SWIG_fail;
46177 }
46178 resultobj = SWIG_Py_Void();
46179 return resultobj;
46180 fail:
46181 return NULL;
46182 }
46183
46184
46185 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46186 PyObject *resultobj = 0;
46187 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46188 int arg2 ;
46189 int arg3 ;
46190 void *argp1 = 0 ;
46191 int res1 = 0 ;
46192 int val2 ;
46193 int ecode2 = 0 ;
46194 int val3 ;
46195 int ecode3 = 0 ;
46196 PyObject * obj0 = 0 ;
46197 PyObject * obj1 = 0 ;
46198 PyObject * obj2 = 0 ;
46199 char * kwnames[] = {
46200 (char *) "self",(char *) "width",(char *) "height", NULL
46201 };
46202
46203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46205 if (!SWIG_IsOK(res1)) {
46206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46207 }
46208 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46209 ecode2 = SWIG_AsVal_int(obj1, &val2);
46210 if (!SWIG_IsOK(ecode2)) {
46211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46212 }
46213 arg2 = static_cast< int >(val2);
46214 ecode3 = SWIG_AsVal_int(obj2, &val3);
46215 if (!SWIG_IsOK(ecode3)) {
46216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46217 }
46218 arg3 = static_cast< int >(val3);
46219 {
46220 PyThreadState* __tstate = wxPyBeginAllowThreads();
46221 (arg1)->SetRatio(arg2,arg3);
46222 wxPyEndAllowThreads(__tstate);
46223 if (PyErr_Occurred()) SWIG_fail;
46224 }
46225 resultobj = SWIG_Py_Void();
46226 return resultobj;
46227 fail:
46228 return NULL;
46229 }
46230
46231
46232 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46233 PyObject *resultobj = 0;
46234 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46235 wxSize *arg2 = 0 ;
46236 void *argp1 = 0 ;
46237 int res1 = 0 ;
46238 wxSize temp2 ;
46239 PyObject * obj0 = 0 ;
46240 PyObject * obj1 = 0 ;
46241 char * kwnames[] = {
46242 (char *) "self",(char *) "size", NULL
46243 };
46244
46245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46247 if (!SWIG_IsOK(res1)) {
46248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46249 }
46250 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46251 {
46252 arg2 = &temp2;
46253 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46254 }
46255 {
46256 PyThreadState* __tstate = wxPyBeginAllowThreads();
46257 (arg1)->SetRatio((wxSize const &)*arg2);
46258 wxPyEndAllowThreads(__tstate);
46259 if (PyErr_Occurred()) SWIG_fail;
46260 }
46261 resultobj = SWIG_Py_Void();
46262 return resultobj;
46263 fail:
46264 return NULL;
46265 }
46266
46267
46268 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46269 PyObject *resultobj = 0;
46270 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46271 float arg2 ;
46272 void *argp1 = 0 ;
46273 int res1 = 0 ;
46274 float val2 ;
46275 int ecode2 = 0 ;
46276 PyObject * obj0 = 0 ;
46277 PyObject * obj1 = 0 ;
46278 char * kwnames[] = {
46279 (char *) "self",(char *) "ratio", NULL
46280 };
46281
46282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46284 if (!SWIG_IsOK(res1)) {
46285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46286 }
46287 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46288 ecode2 = SWIG_AsVal_float(obj1, &val2);
46289 if (!SWIG_IsOK(ecode2)) {
46290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46291 }
46292 arg2 = static_cast< float >(val2);
46293 {
46294 PyThreadState* __tstate = wxPyBeginAllowThreads();
46295 (arg1)->SetRatio(arg2);
46296 wxPyEndAllowThreads(__tstate);
46297 if (PyErr_Occurred()) SWIG_fail;
46298 }
46299 resultobj = SWIG_Py_Void();
46300 return resultobj;
46301 fail:
46302 return NULL;
46303 }
46304
46305
46306 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46307 PyObject *resultobj = 0;
46308 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46309 float result;
46310 void *argp1 = 0 ;
46311 int res1 = 0 ;
46312 PyObject *swig_obj[1] ;
46313
46314 if (!args) SWIG_fail;
46315 swig_obj[0] = args;
46316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46317 if (!SWIG_IsOK(res1)) {
46318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46319 }
46320 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46321 {
46322 PyThreadState* __tstate = wxPyBeginAllowThreads();
46323 result = (float)(arg1)->GetRatio();
46324 wxPyEndAllowThreads(__tstate);
46325 if (PyErr_Occurred()) SWIG_fail;
46326 }
46327 resultobj = SWIG_From_float(static_cast< float >(result));
46328 return resultobj;
46329 fail:
46330 return NULL;
46331 }
46332
46333
46334 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46335 PyObject *resultobj = 0;
46336 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46337 wxRect result;
46338 void *argp1 = 0 ;
46339 int res1 = 0 ;
46340 PyObject *swig_obj[1] ;
46341
46342 if (!args) SWIG_fail;
46343 swig_obj[0] = args;
46344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46345 if (!SWIG_IsOK(res1)) {
46346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46347 }
46348 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46349 {
46350 PyThreadState* __tstate = wxPyBeginAllowThreads();
46351 result = (arg1)->GetRect();
46352 wxPyEndAllowThreads(__tstate);
46353 if (PyErr_Occurred()) SWIG_fail;
46354 }
46355 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46356 return resultobj;
46357 fail:
46358 return NULL;
46359 }
46360
46361
46362 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46363 PyObject *resultobj = 0;
46364 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46365 bool result;
46366 void *argp1 = 0 ;
46367 int res1 = 0 ;
46368 PyObject *swig_obj[1] ;
46369
46370 if (!args) SWIG_fail;
46371 swig_obj[0] = args;
46372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46373 if (!SWIG_IsOK(res1)) {
46374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46375 }
46376 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46377 {
46378 PyThreadState* __tstate = wxPyBeginAllowThreads();
46379 result = (bool)(arg1)->IsWindow();
46380 wxPyEndAllowThreads(__tstate);
46381 if (PyErr_Occurred()) SWIG_fail;
46382 }
46383 {
46384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46385 }
46386 return resultobj;
46387 fail:
46388 return NULL;
46389 }
46390
46391
46392 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46393 PyObject *resultobj = 0;
46394 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46395 bool result;
46396 void *argp1 = 0 ;
46397 int res1 = 0 ;
46398 PyObject *swig_obj[1] ;
46399
46400 if (!args) SWIG_fail;
46401 swig_obj[0] = args;
46402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46403 if (!SWIG_IsOK(res1)) {
46404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46405 }
46406 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46407 {
46408 PyThreadState* __tstate = wxPyBeginAllowThreads();
46409 result = (bool)(arg1)->IsSizer();
46410 wxPyEndAllowThreads(__tstate);
46411 if (PyErr_Occurred()) SWIG_fail;
46412 }
46413 {
46414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46415 }
46416 return resultobj;
46417 fail:
46418 return NULL;
46419 }
46420
46421
46422 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46423 PyObject *resultobj = 0;
46424 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46425 bool result;
46426 void *argp1 = 0 ;
46427 int res1 = 0 ;
46428 PyObject *swig_obj[1] ;
46429
46430 if (!args) SWIG_fail;
46431 swig_obj[0] = args;
46432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46433 if (!SWIG_IsOK(res1)) {
46434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46435 }
46436 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46437 {
46438 PyThreadState* __tstate = wxPyBeginAllowThreads();
46439 result = (bool)(arg1)->IsSpacer();
46440 wxPyEndAllowThreads(__tstate);
46441 if (PyErr_Occurred()) SWIG_fail;
46442 }
46443 {
46444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46445 }
46446 return resultobj;
46447 fail:
46448 return NULL;
46449 }
46450
46451
46452 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46453 PyObject *resultobj = 0;
46454 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46455 int arg2 ;
46456 void *argp1 = 0 ;
46457 int res1 = 0 ;
46458 int val2 ;
46459 int ecode2 = 0 ;
46460 PyObject * obj0 = 0 ;
46461 PyObject * obj1 = 0 ;
46462 char * kwnames[] = {
46463 (char *) "self",(char *) "proportion", NULL
46464 };
46465
46466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46468 if (!SWIG_IsOK(res1)) {
46469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46470 }
46471 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46472 ecode2 = SWIG_AsVal_int(obj1, &val2);
46473 if (!SWIG_IsOK(ecode2)) {
46474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46475 }
46476 arg2 = static_cast< int >(val2);
46477 {
46478 PyThreadState* __tstate = wxPyBeginAllowThreads();
46479 (arg1)->SetProportion(arg2);
46480 wxPyEndAllowThreads(__tstate);
46481 if (PyErr_Occurred()) SWIG_fail;
46482 }
46483 resultobj = SWIG_Py_Void();
46484 return resultobj;
46485 fail:
46486 return NULL;
46487 }
46488
46489
46490 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46491 PyObject *resultobj = 0;
46492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46493 int result;
46494 void *argp1 = 0 ;
46495 int res1 = 0 ;
46496 PyObject *swig_obj[1] ;
46497
46498 if (!args) SWIG_fail;
46499 swig_obj[0] = args;
46500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46501 if (!SWIG_IsOK(res1)) {
46502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46503 }
46504 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46505 {
46506 PyThreadState* __tstate = wxPyBeginAllowThreads();
46507 result = (int)(arg1)->GetProportion();
46508 wxPyEndAllowThreads(__tstate);
46509 if (PyErr_Occurred()) SWIG_fail;
46510 }
46511 resultobj = SWIG_From_int(static_cast< int >(result));
46512 return resultobj;
46513 fail:
46514 return NULL;
46515 }
46516
46517
46518 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46519 PyObject *resultobj = 0;
46520 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46521 int arg2 ;
46522 void *argp1 = 0 ;
46523 int res1 = 0 ;
46524 int val2 ;
46525 int ecode2 = 0 ;
46526 PyObject * obj0 = 0 ;
46527 PyObject * obj1 = 0 ;
46528 char * kwnames[] = {
46529 (char *) "self",(char *) "flag", NULL
46530 };
46531
46532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46534 if (!SWIG_IsOK(res1)) {
46535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46536 }
46537 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46538 ecode2 = SWIG_AsVal_int(obj1, &val2);
46539 if (!SWIG_IsOK(ecode2)) {
46540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46541 }
46542 arg2 = static_cast< int >(val2);
46543 {
46544 PyThreadState* __tstate = wxPyBeginAllowThreads();
46545 (arg1)->SetFlag(arg2);
46546 wxPyEndAllowThreads(__tstate);
46547 if (PyErr_Occurred()) SWIG_fail;
46548 }
46549 resultobj = SWIG_Py_Void();
46550 return resultobj;
46551 fail:
46552 return NULL;
46553 }
46554
46555
46556 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46557 PyObject *resultobj = 0;
46558 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46559 int result;
46560 void *argp1 = 0 ;
46561 int res1 = 0 ;
46562 PyObject *swig_obj[1] ;
46563
46564 if (!args) SWIG_fail;
46565 swig_obj[0] = args;
46566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46567 if (!SWIG_IsOK(res1)) {
46568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46569 }
46570 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46571 {
46572 PyThreadState* __tstate = wxPyBeginAllowThreads();
46573 result = (int)(arg1)->GetFlag();
46574 wxPyEndAllowThreads(__tstate);
46575 if (PyErr_Occurred()) SWIG_fail;
46576 }
46577 resultobj = SWIG_From_int(static_cast< int >(result));
46578 return resultobj;
46579 fail:
46580 return NULL;
46581 }
46582
46583
46584 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46585 PyObject *resultobj = 0;
46586 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46587 int arg2 ;
46588 void *argp1 = 0 ;
46589 int res1 = 0 ;
46590 int val2 ;
46591 int ecode2 = 0 ;
46592 PyObject * obj0 = 0 ;
46593 PyObject * obj1 = 0 ;
46594 char * kwnames[] = {
46595 (char *) "self",(char *) "border", NULL
46596 };
46597
46598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46600 if (!SWIG_IsOK(res1)) {
46601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46602 }
46603 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46604 ecode2 = SWIG_AsVal_int(obj1, &val2);
46605 if (!SWIG_IsOK(ecode2)) {
46606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46607 }
46608 arg2 = static_cast< int >(val2);
46609 {
46610 PyThreadState* __tstate = wxPyBeginAllowThreads();
46611 (arg1)->SetBorder(arg2);
46612 wxPyEndAllowThreads(__tstate);
46613 if (PyErr_Occurred()) SWIG_fail;
46614 }
46615 resultobj = SWIG_Py_Void();
46616 return resultobj;
46617 fail:
46618 return NULL;
46619 }
46620
46621
46622 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46623 PyObject *resultobj = 0;
46624 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46625 int result;
46626 void *argp1 = 0 ;
46627 int res1 = 0 ;
46628 PyObject *swig_obj[1] ;
46629
46630 if (!args) SWIG_fail;
46631 swig_obj[0] = args;
46632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46633 if (!SWIG_IsOK(res1)) {
46634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46635 }
46636 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46637 {
46638 PyThreadState* __tstate = wxPyBeginAllowThreads();
46639 result = (int)(arg1)->GetBorder();
46640 wxPyEndAllowThreads(__tstate);
46641 if (PyErr_Occurred()) SWIG_fail;
46642 }
46643 resultobj = SWIG_From_int(static_cast< int >(result));
46644 return resultobj;
46645 fail:
46646 return NULL;
46647 }
46648
46649
46650 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46651 PyObject *resultobj = 0;
46652 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46653 wxWindow *result = 0 ;
46654 void *argp1 = 0 ;
46655 int res1 = 0 ;
46656 PyObject *swig_obj[1] ;
46657
46658 if (!args) SWIG_fail;
46659 swig_obj[0] = args;
46660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46661 if (!SWIG_IsOK(res1)) {
46662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46663 }
46664 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46665 {
46666 PyThreadState* __tstate = wxPyBeginAllowThreads();
46667 result = (wxWindow *)(arg1)->GetWindow();
46668 wxPyEndAllowThreads(__tstate);
46669 if (PyErr_Occurred()) SWIG_fail;
46670 }
46671 {
46672 resultobj = wxPyMake_wxObject(result, 0);
46673 }
46674 return resultobj;
46675 fail:
46676 return NULL;
46677 }
46678
46679
46680 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46681 PyObject *resultobj = 0;
46682 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46683 wxWindow *arg2 = (wxWindow *) 0 ;
46684 void *argp1 = 0 ;
46685 int res1 = 0 ;
46686 void *argp2 = 0 ;
46687 int res2 = 0 ;
46688 PyObject * obj0 = 0 ;
46689 PyObject * obj1 = 0 ;
46690 char * kwnames[] = {
46691 (char *) "self",(char *) "window", NULL
46692 };
46693
46694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46696 if (!SWIG_IsOK(res1)) {
46697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46698 }
46699 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46700 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46701 if (!SWIG_IsOK(res2)) {
46702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46703 }
46704 arg2 = reinterpret_cast< wxWindow * >(argp2);
46705 {
46706 PyThreadState* __tstate = wxPyBeginAllowThreads();
46707 (arg1)->SetWindow(arg2);
46708 wxPyEndAllowThreads(__tstate);
46709 if (PyErr_Occurred()) SWIG_fail;
46710 }
46711 resultobj = SWIG_Py_Void();
46712 return resultobj;
46713 fail:
46714 return NULL;
46715 }
46716
46717
46718 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46719 PyObject *resultobj = 0;
46720 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46721 wxSizer *result = 0 ;
46722 void *argp1 = 0 ;
46723 int res1 = 0 ;
46724 PyObject *swig_obj[1] ;
46725
46726 if (!args) SWIG_fail;
46727 swig_obj[0] = args;
46728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46729 if (!SWIG_IsOK(res1)) {
46730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46731 }
46732 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46733 {
46734 PyThreadState* __tstate = wxPyBeginAllowThreads();
46735 result = (wxSizer *)(arg1)->GetSizer();
46736 wxPyEndAllowThreads(__tstate);
46737 if (PyErr_Occurred()) SWIG_fail;
46738 }
46739 {
46740 resultobj = wxPyMake_wxObject(result, (bool)0);
46741 }
46742 return resultobj;
46743 fail:
46744 return NULL;
46745 }
46746
46747
46748 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46749 PyObject *resultobj = 0;
46750 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46751 wxSizer *arg2 = (wxSizer *) 0 ;
46752 void *argp1 = 0 ;
46753 int res1 = 0 ;
46754 int res2 = 0 ;
46755 PyObject * obj0 = 0 ;
46756 PyObject * obj1 = 0 ;
46757 char * kwnames[] = {
46758 (char *) "self",(char *) "sizer", NULL
46759 };
46760
46761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46763 if (!SWIG_IsOK(res1)) {
46764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46765 }
46766 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46767 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46768 if (!SWIG_IsOK(res2)) {
46769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46770 }
46771 {
46772 PyThreadState* __tstate = wxPyBeginAllowThreads();
46773 (arg1)->SetSizer(arg2);
46774 wxPyEndAllowThreads(__tstate);
46775 if (PyErr_Occurred()) SWIG_fail;
46776 }
46777 resultobj = SWIG_Py_Void();
46778 return resultobj;
46779 fail:
46780 return NULL;
46781 }
46782
46783
46784 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46785 PyObject *resultobj = 0;
46786 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46787 wxSize *result = 0 ;
46788 void *argp1 = 0 ;
46789 int res1 = 0 ;
46790 PyObject *swig_obj[1] ;
46791
46792 if (!args) SWIG_fail;
46793 swig_obj[0] = args;
46794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46795 if (!SWIG_IsOK(res1)) {
46796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46797 }
46798 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46799 {
46800 PyThreadState* __tstate = wxPyBeginAllowThreads();
46801 {
46802 wxSize const &_result_ref = (arg1)->GetSpacer();
46803 result = (wxSize *) &_result_ref;
46804 }
46805 wxPyEndAllowThreads(__tstate);
46806 if (PyErr_Occurred()) SWIG_fail;
46807 }
46808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46809 return resultobj;
46810 fail:
46811 return NULL;
46812 }
46813
46814
46815 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46816 PyObject *resultobj = 0;
46817 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46818 wxSize *arg2 = 0 ;
46819 void *argp1 = 0 ;
46820 int res1 = 0 ;
46821 wxSize temp2 ;
46822 PyObject * obj0 = 0 ;
46823 PyObject * obj1 = 0 ;
46824 char * kwnames[] = {
46825 (char *) "self",(char *) "size", NULL
46826 };
46827
46828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46830 if (!SWIG_IsOK(res1)) {
46831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46832 }
46833 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46834 {
46835 arg2 = &temp2;
46836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46837 }
46838 {
46839 PyThreadState* __tstate = wxPyBeginAllowThreads();
46840 (arg1)->SetSpacer((wxSize const &)*arg2);
46841 wxPyEndAllowThreads(__tstate);
46842 if (PyErr_Occurred()) SWIG_fail;
46843 }
46844 resultobj = SWIG_Py_Void();
46845 return resultobj;
46846 fail:
46847 return NULL;
46848 }
46849
46850
46851 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46852 PyObject *resultobj = 0;
46853 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46854 bool arg2 ;
46855 void *argp1 = 0 ;
46856 int res1 = 0 ;
46857 bool val2 ;
46858 int ecode2 = 0 ;
46859 PyObject * obj0 = 0 ;
46860 PyObject * obj1 = 0 ;
46861 char * kwnames[] = {
46862 (char *) "self",(char *) "show", NULL
46863 };
46864
46865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46867 if (!SWIG_IsOK(res1)) {
46868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46869 }
46870 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46871 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46872 if (!SWIG_IsOK(ecode2)) {
46873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46874 }
46875 arg2 = static_cast< bool >(val2);
46876 {
46877 PyThreadState* __tstate = wxPyBeginAllowThreads();
46878 (arg1)->Show(arg2);
46879 wxPyEndAllowThreads(__tstate);
46880 if (PyErr_Occurred()) SWIG_fail;
46881 }
46882 resultobj = SWIG_Py_Void();
46883 return resultobj;
46884 fail:
46885 return NULL;
46886 }
46887
46888
46889 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46890 PyObject *resultobj = 0;
46891 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46892 bool result;
46893 void *argp1 = 0 ;
46894 int res1 = 0 ;
46895 PyObject *swig_obj[1] ;
46896
46897 if (!args) SWIG_fail;
46898 swig_obj[0] = args;
46899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46900 if (!SWIG_IsOK(res1)) {
46901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46902 }
46903 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46904 {
46905 PyThreadState* __tstate = wxPyBeginAllowThreads();
46906 result = (bool)(arg1)->IsShown();
46907 wxPyEndAllowThreads(__tstate);
46908 if (PyErr_Occurred()) SWIG_fail;
46909 }
46910 {
46911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46912 }
46913 return resultobj;
46914 fail:
46915 return NULL;
46916 }
46917
46918
46919 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46920 PyObject *resultobj = 0;
46921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46922 wxPoint result;
46923 void *argp1 = 0 ;
46924 int res1 = 0 ;
46925 PyObject *swig_obj[1] ;
46926
46927 if (!args) SWIG_fail;
46928 swig_obj[0] = args;
46929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46930 if (!SWIG_IsOK(res1)) {
46931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46932 }
46933 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46934 {
46935 PyThreadState* __tstate = wxPyBeginAllowThreads();
46936 result = (arg1)->GetPosition();
46937 wxPyEndAllowThreads(__tstate);
46938 if (PyErr_Occurred()) SWIG_fail;
46939 }
46940 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46941 return resultobj;
46942 fail:
46943 return NULL;
46944 }
46945
46946
46947 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46948 PyObject *resultobj = 0;
46949 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46950 PyObject *result = 0 ;
46951 void *argp1 = 0 ;
46952 int res1 = 0 ;
46953 PyObject *swig_obj[1] ;
46954
46955 if (!args) SWIG_fail;
46956 swig_obj[0] = args;
46957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46958 if (!SWIG_IsOK(res1)) {
46959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46960 }
46961 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46962 {
46963 PyThreadState* __tstate = wxPyBeginAllowThreads();
46964 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46965 wxPyEndAllowThreads(__tstate);
46966 if (PyErr_Occurred()) SWIG_fail;
46967 }
46968 resultobj = result;
46969 return resultobj;
46970 fail:
46971 return NULL;
46972 }
46973
46974
46975 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46976 PyObject *resultobj = 0;
46977 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46978 PyObject *arg2 = (PyObject *) 0 ;
46979 void *argp1 = 0 ;
46980 int res1 = 0 ;
46981 PyObject * obj0 = 0 ;
46982 PyObject * obj1 = 0 ;
46983 char * kwnames[] = {
46984 (char *) "self",(char *) "userData", NULL
46985 };
46986
46987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46989 if (!SWIG_IsOK(res1)) {
46990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46991 }
46992 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46993 arg2 = obj1;
46994 {
46995 PyThreadState* __tstate = wxPyBeginAllowThreads();
46996 wxSizerItem_SetUserData(arg1,arg2);
46997 wxPyEndAllowThreads(__tstate);
46998 if (PyErr_Occurred()) SWIG_fail;
46999 }
47000 resultobj = SWIG_Py_Void();
47001 return resultobj;
47002 fail:
47003 return NULL;
47004 }
47005
47006
47007 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47008 PyObject *obj;
47009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47010 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47011 return SWIG_Py_Void();
47012 }
47013
47014 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47015 return SWIG_Python_InitShadowInstance(args);
47016 }
47017
47018 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47019 PyObject *resultobj = 0;
47020 wxSizer *arg1 = (wxSizer *) 0 ;
47021 void *argp1 = 0 ;
47022 int res1 = 0 ;
47023 PyObject *swig_obj[1] ;
47024
47025 if (!args) SWIG_fail;
47026 swig_obj[0] = args;
47027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47028 if (!SWIG_IsOK(res1)) {
47029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47030 }
47031 arg1 = reinterpret_cast< wxSizer * >(argp1);
47032 {
47033 PyThreadState* __tstate = wxPyBeginAllowThreads();
47034 delete arg1;
47035
47036 wxPyEndAllowThreads(__tstate);
47037 if (PyErr_Occurred()) SWIG_fail;
47038 }
47039 resultobj = SWIG_Py_Void();
47040 return resultobj;
47041 fail:
47042 return NULL;
47043 }
47044
47045
47046 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47047 PyObject *resultobj = 0;
47048 wxSizer *arg1 = (wxSizer *) 0 ;
47049 PyObject *arg2 = (PyObject *) 0 ;
47050 void *argp1 = 0 ;
47051 int res1 = 0 ;
47052 PyObject * obj0 = 0 ;
47053 PyObject * obj1 = 0 ;
47054 char * kwnames[] = {
47055 (char *) "self",(char *) "_self", NULL
47056 };
47057
47058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47060 if (!SWIG_IsOK(res1)) {
47061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47062 }
47063 arg1 = reinterpret_cast< wxSizer * >(argp1);
47064 arg2 = obj1;
47065 {
47066 PyThreadState* __tstate = wxPyBeginAllowThreads();
47067 wxSizer__setOORInfo(arg1,arg2);
47068 wxPyEndAllowThreads(__tstate);
47069 if (PyErr_Occurred()) SWIG_fail;
47070 }
47071 resultobj = SWIG_Py_Void();
47072 return resultobj;
47073 fail:
47074 return NULL;
47075 }
47076
47077
47078 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47079 PyObject *resultobj = 0;
47080 wxSizer *arg1 = (wxSizer *) 0 ;
47081 PyObject *arg2 = (PyObject *) 0 ;
47082 int arg3 = (int) 0 ;
47083 int arg4 = (int) 0 ;
47084 int arg5 = (int) 0 ;
47085 PyObject *arg6 = (PyObject *) NULL ;
47086 wxSizerItem *result = 0 ;
47087 void *argp1 = 0 ;
47088 int res1 = 0 ;
47089 int val3 ;
47090 int ecode3 = 0 ;
47091 int val4 ;
47092 int ecode4 = 0 ;
47093 int val5 ;
47094 int ecode5 = 0 ;
47095 PyObject * obj0 = 0 ;
47096 PyObject * obj1 = 0 ;
47097 PyObject * obj2 = 0 ;
47098 PyObject * obj3 = 0 ;
47099 PyObject * obj4 = 0 ;
47100 PyObject * obj5 = 0 ;
47101 char * kwnames[] = {
47102 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47103 };
47104
47105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47107 if (!SWIG_IsOK(res1)) {
47108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47109 }
47110 arg1 = reinterpret_cast< wxSizer * >(argp1);
47111 arg2 = obj1;
47112 if (obj2) {
47113 ecode3 = SWIG_AsVal_int(obj2, &val3);
47114 if (!SWIG_IsOK(ecode3)) {
47115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47116 }
47117 arg3 = static_cast< int >(val3);
47118 }
47119 if (obj3) {
47120 ecode4 = SWIG_AsVal_int(obj3, &val4);
47121 if (!SWIG_IsOK(ecode4)) {
47122 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47123 }
47124 arg4 = static_cast< int >(val4);
47125 }
47126 if (obj4) {
47127 ecode5 = SWIG_AsVal_int(obj4, &val5);
47128 if (!SWIG_IsOK(ecode5)) {
47129 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47130 }
47131 arg5 = static_cast< int >(val5);
47132 }
47133 if (obj5) {
47134 arg6 = obj5;
47135 }
47136 {
47137 PyThreadState* __tstate = wxPyBeginAllowThreads();
47138 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47139 wxPyEndAllowThreads(__tstate);
47140 if (PyErr_Occurred()) SWIG_fail;
47141 }
47142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47143 return resultobj;
47144 fail:
47145 return NULL;
47146 }
47147
47148
47149 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47150 PyObject *resultobj = 0;
47151 wxSizer *arg1 = (wxSizer *) 0 ;
47152 int arg2 ;
47153 PyObject *arg3 = (PyObject *) 0 ;
47154 int arg4 = (int) 0 ;
47155 int arg5 = (int) 0 ;
47156 int arg6 = (int) 0 ;
47157 PyObject *arg7 = (PyObject *) NULL ;
47158 wxSizerItem *result = 0 ;
47159 void *argp1 = 0 ;
47160 int res1 = 0 ;
47161 int val2 ;
47162 int ecode2 = 0 ;
47163 int val4 ;
47164 int ecode4 = 0 ;
47165 int val5 ;
47166 int ecode5 = 0 ;
47167 int val6 ;
47168 int ecode6 = 0 ;
47169 PyObject * obj0 = 0 ;
47170 PyObject * obj1 = 0 ;
47171 PyObject * obj2 = 0 ;
47172 PyObject * obj3 = 0 ;
47173 PyObject * obj4 = 0 ;
47174 PyObject * obj5 = 0 ;
47175 PyObject * obj6 = 0 ;
47176 char * kwnames[] = {
47177 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47178 };
47179
47180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47182 if (!SWIG_IsOK(res1)) {
47183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47184 }
47185 arg1 = reinterpret_cast< wxSizer * >(argp1);
47186 ecode2 = SWIG_AsVal_int(obj1, &val2);
47187 if (!SWIG_IsOK(ecode2)) {
47188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47189 }
47190 arg2 = static_cast< int >(val2);
47191 arg3 = obj2;
47192 if (obj3) {
47193 ecode4 = SWIG_AsVal_int(obj3, &val4);
47194 if (!SWIG_IsOK(ecode4)) {
47195 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47196 }
47197 arg4 = static_cast< int >(val4);
47198 }
47199 if (obj4) {
47200 ecode5 = SWIG_AsVal_int(obj4, &val5);
47201 if (!SWIG_IsOK(ecode5)) {
47202 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47203 }
47204 arg5 = static_cast< int >(val5);
47205 }
47206 if (obj5) {
47207 ecode6 = SWIG_AsVal_int(obj5, &val6);
47208 if (!SWIG_IsOK(ecode6)) {
47209 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47210 }
47211 arg6 = static_cast< int >(val6);
47212 }
47213 if (obj6) {
47214 arg7 = obj6;
47215 }
47216 {
47217 PyThreadState* __tstate = wxPyBeginAllowThreads();
47218 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47219 wxPyEndAllowThreads(__tstate);
47220 if (PyErr_Occurred()) SWIG_fail;
47221 }
47222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47223 return resultobj;
47224 fail:
47225 return NULL;
47226 }
47227
47228
47229 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47230 PyObject *resultobj = 0;
47231 wxSizer *arg1 = (wxSizer *) 0 ;
47232 PyObject *arg2 = (PyObject *) 0 ;
47233 int arg3 = (int) 0 ;
47234 int arg4 = (int) 0 ;
47235 int arg5 = (int) 0 ;
47236 PyObject *arg6 = (PyObject *) NULL ;
47237 wxSizerItem *result = 0 ;
47238 void *argp1 = 0 ;
47239 int res1 = 0 ;
47240 int val3 ;
47241 int ecode3 = 0 ;
47242 int val4 ;
47243 int ecode4 = 0 ;
47244 int val5 ;
47245 int ecode5 = 0 ;
47246 PyObject * obj0 = 0 ;
47247 PyObject * obj1 = 0 ;
47248 PyObject * obj2 = 0 ;
47249 PyObject * obj3 = 0 ;
47250 PyObject * obj4 = 0 ;
47251 PyObject * obj5 = 0 ;
47252 char * kwnames[] = {
47253 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47254 };
47255
47256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47260 }
47261 arg1 = reinterpret_cast< wxSizer * >(argp1);
47262 arg2 = obj1;
47263 if (obj2) {
47264 ecode3 = SWIG_AsVal_int(obj2, &val3);
47265 if (!SWIG_IsOK(ecode3)) {
47266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47267 }
47268 arg3 = static_cast< int >(val3);
47269 }
47270 if (obj3) {
47271 ecode4 = SWIG_AsVal_int(obj3, &val4);
47272 if (!SWIG_IsOK(ecode4)) {
47273 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47274 }
47275 arg4 = static_cast< int >(val4);
47276 }
47277 if (obj4) {
47278 ecode5 = SWIG_AsVal_int(obj4, &val5);
47279 if (!SWIG_IsOK(ecode5)) {
47280 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47281 }
47282 arg5 = static_cast< int >(val5);
47283 }
47284 if (obj5) {
47285 arg6 = obj5;
47286 }
47287 {
47288 PyThreadState* __tstate = wxPyBeginAllowThreads();
47289 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47290 wxPyEndAllowThreads(__tstate);
47291 if (PyErr_Occurred()) SWIG_fail;
47292 }
47293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47294 return resultobj;
47295 fail:
47296 return NULL;
47297 }
47298
47299
47300 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47301 PyObject *resultobj = 0;
47302 wxSizer *arg1 = (wxSizer *) 0 ;
47303 PyObject *arg2 = (PyObject *) 0 ;
47304 bool result;
47305 void *argp1 = 0 ;
47306 int res1 = 0 ;
47307 PyObject * obj0 = 0 ;
47308 PyObject * obj1 = 0 ;
47309 char * kwnames[] = {
47310 (char *) "self",(char *) "item", NULL
47311 };
47312
47313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47315 if (!SWIG_IsOK(res1)) {
47316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47317 }
47318 arg1 = reinterpret_cast< wxSizer * >(argp1);
47319 arg2 = obj1;
47320 {
47321 PyThreadState* __tstate = wxPyBeginAllowThreads();
47322 result = (bool)wxSizer_Remove(arg1,arg2);
47323 wxPyEndAllowThreads(__tstate);
47324 if (PyErr_Occurred()) SWIG_fail;
47325 }
47326 {
47327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47328 }
47329 return resultobj;
47330 fail:
47331 return NULL;
47332 }
47333
47334
47335 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47336 PyObject *resultobj = 0;
47337 wxSizer *arg1 = (wxSizer *) 0 ;
47338 PyObject *arg2 = (PyObject *) 0 ;
47339 bool result;
47340 void *argp1 = 0 ;
47341 int res1 = 0 ;
47342 PyObject * obj0 = 0 ;
47343 PyObject * obj1 = 0 ;
47344 char * kwnames[] = {
47345 (char *) "self",(char *) "item", NULL
47346 };
47347
47348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47350 if (!SWIG_IsOK(res1)) {
47351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47352 }
47353 arg1 = reinterpret_cast< wxSizer * >(argp1);
47354 arg2 = obj1;
47355 {
47356 PyThreadState* __tstate = wxPyBeginAllowThreads();
47357 result = (bool)wxSizer_Detach(arg1,arg2);
47358 wxPyEndAllowThreads(__tstate);
47359 if (PyErr_Occurred()) SWIG_fail;
47360 }
47361 {
47362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47363 }
47364 return resultobj;
47365 fail:
47366 return NULL;
47367 }
47368
47369
47370 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47371 PyObject *resultobj = 0;
47372 wxSizer *arg1 = (wxSizer *) 0 ;
47373 PyObject *arg2 = (PyObject *) 0 ;
47374 wxSizerItem *result = 0 ;
47375 void *argp1 = 0 ;
47376 int res1 = 0 ;
47377 PyObject * obj0 = 0 ;
47378 PyObject * obj1 = 0 ;
47379 char * kwnames[] = {
47380 (char *) "self",(char *) "item", NULL
47381 };
47382
47383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47385 if (!SWIG_IsOK(res1)) {
47386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47387 }
47388 arg1 = reinterpret_cast< wxSizer * >(argp1);
47389 arg2 = obj1;
47390 {
47391 PyThreadState* __tstate = wxPyBeginAllowThreads();
47392 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47393 wxPyEndAllowThreads(__tstate);
47394 if (PyErr_Occurred()) SWIG_fail;
47395 }
47396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47397 return resultobj;
47398 fail:
47399 return NULL;
47400 }
47401
47402
47403 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47404 PyObject *resultobj = 0;
47405 wxSizer *arg1 = (wxSizer *) 0 ;
47406 PyObject *arg2 = (PyObject *) 0 ;
47407 wxSize *arg3 = 0 ;
47408 void *argp1 = 0 ;
47409 int res1 = 0 ;
47410 wxSize temp3 ;
47411 PyObject * obj0 = 0 ;
47412 PyObject * obj1 = 0 ;
47413 PyObject * obj2 = 0 ;
47414 char * kwnames[] = {
47415 (char *) "self",(char *) "item",(char *) "size", NULL
47416 };
47417
47418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47420 if (!SWIG_IsOK(res1)) {
47421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47422 }
47423 arg1 = reinterpret_cast< wxSizer * >(argp1);
47424 arg2 = obj1;
47425 {
47426 arg3 = &temp3;
47427 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47428 }
47429 {
47430 PyThreadState* __tstate = wxPyBeginAllowThreads();
47431 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47432 wxPyEndAllowThreads(__tstate);
47433 if (PyErr_Occurred()) SWIG_fail;
47434 }
47435 resultobj = SWIG_Py_Void();
47436 return resultobj;
47437 fail:
47438 return NULL;
47439 }
47440
47441
47442 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47443 PyObject *resultobj = 0;
47444 wxSizer *arg1 = (wxSizer *) 0 ;
47445 wxWindow *arg2 = (wxWindow *) 0 ;
47446 wxWindow *arg3 = (wxWindow *) 0 ;
47447 bool arg4 = (bool) false ;
47448 bool result;
47449 void *argp1 = 0 ;
47450 int res1 = 0 ;
47451 void *argp2 = 0 ;
47452 int res2 = 0 ;
47453 void *argp3 = 0 ;
47454 int res3 = 0 ;
47455 bool val4 ;
47456 int ecode4 = 0 ;
47457 PyObject * obj0 = 0 ;
47458 PyObject * obj1 = 0 ;
47459 PyObject * obj2 = 0 ;
47460 PyObject * obj3 = 0 ;
47461 char * kwnames[] = {
47462 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47463 };
47464
47465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47467 if (!SWIG_IsOK(res1)) {
47468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47469 }
47470 arg1 = reinterpret_cast< wxSizer * >(argp1);
47471 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47472 if (!SWIG_IsOK(res2)) {
47473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47474 }
47475 arg2 = reinterpret_cast< wxWindow * >(argp2);
47476 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47477 if (!SWIG_IsOK(res3)) {
47478 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47479 }
47480 arg3 = reinterpret_cast< wxWindow * >(argp3);
47481 if (obj3) {
47482 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47483 if (!SWIG_IsOK(ecode4)) {
47484 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47485 }
47486 arg4 = static_cast< bool >(val4);
47487 }
47488 {
47489 PyThreadState* __tstate = wxPyBeginAllowThreads();
47490 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47491 wxPyEndAllowThreads(__tstate);
47492 if (PyErr_Occurred()) SWIG_fail;
47493 }
47494 {
47495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47496 }
47497 return resultobj;
47498 fail:
47499 return NULL;
47500 }
47501
47502
47503 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47504 PyObject *resultobj = 0;
47505 wxSizer *arg1 = (wxSizer *) 0 ;
47506 wxSizer *arg2 = (wxSizer *) 0 ;
47507 wxSizer *arg3 = (wxSizer *) 0 ;
47508 bool arg4 = (bool) false ;
47509 bool result;
47510 void *argp1 = 0 ;
47511 int res1 = 0 ;
47512 void *argp2 = 0 ;
47513 int res2 = 0 ;
47514 void *argp3 = 0 ;
47515 int res3 = 0 ;
47516 bool val4 ;
47517 int ecode4 = 0 ;
47518 PyObject * obj0 = 0 ;
47519 PyObject * obj1 = 0 ;
47520 PyObject * obj2 = 0 ;
47521 PyObject * obj3 = 0 ;
47522 char * kwnames[] = {
47523 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47524 };
47525
47526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47528 if (!SWIG_IsOK(res1)) {
47529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47530 }
47531 arg1 = reinterpret_cast< wxSizer * >(argp1);
47532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47533 if (!SWIG_IsOK(res2)) {
47534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47535 }
47536 arg2 = reinterpret_cast< wxSizer * >(argp2);
47537 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47538 if (!SWIG_IsOK(res3)) {
47539 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47540 }
47541 arg3 = reinterpret_cast< wxSizer * >(argp3);
47542 if (obj3) {
47543 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47544 if (!SWIG_IsOK(ecode4)) {
47545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47546 }
47547 arg4 = static_cast< bool >(val4);
47548 }
47549 {
47550 PyThreadState* __tstate = wxPyBeginAllowThreads();
47551 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47552 wxPyEndAllowThreads(__tstate);
47553 if (PyErr_Occurred()) SWIG_fail;
47554 }
47555 {
47556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47557 }
47558 return resultobj;
47559 fail:
47560 return NULL;
47561 }
47562
47563
47564 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47565 PyObject *resultobj = 0;
47566 wxSizer *arg1 = (wxSizer *) 0 ;
47567 size_t arg2 ;
47568 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47569 bool result;
47570 void *argp1 = 0 ;
47571 int res1 = 0 ;
47572 size_t val2 ;
47573 int ecode2 = 0 ;
47574 void *argp3 = 0 ;
47575 int res3 = 0 ;
47576 PyObject * obj0 = 0 ;
47577 PyObject * obj1 = 0 ;
47578 PyObject * obj2 = 0 ;
47579 char * kwnames[] = {
47580 (char *) "self",(char *) "index",(char *) "newitem", NULL
47581 };
47582
47583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47585 if (!SWIG_IsOK(res1)) {
47586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47587 }
47588 arg1 = reinterpret_cast< wxSizer * >(argp1);
47589 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47590 if (!SWIG_IsOK(ecode2)) {
47591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47592 }
47593 arg2 = static_cast< size_t >(val2);
47594 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47595 if (!SWIG_IsOK(res3)) {
47596 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47597 }
47598 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47599 {
47600 PyThreadState* __tstate = wxPyBeginAllowThreads();
47601 result = (bool)(arg1)->Replace(arg2,arg3);
47602 wxPyEndAllowThreads(__tstate);
47603 if (PyErr_Occurred()) SWIG_fail;
47604 }
47605 {
47606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47607 }
47608 return resultobj;
47609 fail:
47610 return NULL;
47611 }
47612
47613
47614 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47615 PyObject *resultobj = 0;
47616 wxSizer *arg1 = (wxSizer *) 0 ;
47617 wxWindow *arg2 = (wxWindow *) 0 ;
47618 void *argp1 = 0 ;
47619 int res1 = 0 ;
47620 void *argp2 = 0 ;
47621 int res2 = 0 ;
47622 PyObject * obj0 = 0 ;
47623 PyObject * obj1 = 0 ;
47624 char * kwnames[] = {
47625 (char *) "self",(char *) "window", NULL
47626 };
47627
47628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47630 if (!SWIG_IsOK(res1)) {
47631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47632 }
47633 arg1 = reinterpret_cast< wxSizer * >(argp1);
47634 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47635 if (!SWIG_IsOK(res2)) {
47636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47637 }
47638 arg2 = reinterpret_cast< wxWindow * >(argp2);
47639 {
47640 PyThreadState* __tstate = wxPyBeginAllowThreads();
47641 (arg1)->SetContainingWindow(arg2);
47642 wxPyEndAllowThreads(__tstate);
47643 if (PyErr_Occurred()) SWIG_fail;
47644 }
47645 resultobj = SWIG_Py_Void();
47646 return resultobj;
47647 fail:
47648 return NULL;
47649 }
47650
47651
47652 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47653 PyObject *resultobj = 0;
47654 wxSizer *arg1 = (wxSizer *) 0 ;
47655 wxWindow *result = 0 ;
47656 void *argp1 = 0 ;
47657 int res1 = 0 ;
47658 PyObject *swig_obj[1] ;
47659
47660 if (!args) SWIG_fail;
47661 swig_obj[0] = args;
47662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47663 if (!SWIG_IsOK(res1)) {
47664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47665 }
47666 arg1 = reinterpret_cast< wxSizer * >(argp1);
47667 {
47668 PyThreadState* __tstate = wxPyBeginAllowThreads();
47669 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47670 wxPyEndAllowThreads(__tstate);
47671 if (PyErr_Occurred()) SWIG_fail;
47672 }
47673 {
47674 resultobj = wxPyMake_wxObject(result, 0);
47675 }
47676 return resultobj;
47677 fail:
47678 return NULL;
47679 }
47680
47681
47682 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47683 PyObject *resultobj = 0;
47684 wxSizer *arg1 = (wxSizer *) 0 ;
47685 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47686 wxSizerItem *result = 0 ;
47687 void *argp1 = 0 ;
47688 int res1 = 0 ;
47689 int res2 = 0 ;
47690 PyObject * obj0 = 0 ;
47691 PyObject * obj1 = 0 ;
47692 char * kwnames[] = {
47693 (char *) "self",(char *) "item", NULL
47694 };
47695
47696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47698 if (!SWIG_IsOK(res1)) {
47699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47700 }
47701 arg1 = reinterpret_cast< wxSizer * >(argp1);
47702 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47703 if (!SWIG_IsOK(res2)) {
47704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47705 }
47706 {
47707 PyThreadState* __tstate = wxPyBeginAllowThreads();
47708 result = (wxSizerItem *)(arg1)->Add(arg2);
47709 wxPyEndAllowThreads(__tstate);
47710 if (PyErr_Occurred()) SWIG_fail;
47711 }
47712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47713 return resultobj;
47714 fail:
47715 return NULL;
47716 }
47717
47718
47719 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47720 PyObject *resultobj = 0;
47721 wxSizer *arg1 = (wxSizer *) 0 ;
47722 size_t arg2 ;
47723 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47724 wxSizerItem *result = 0 ;
47725 void *argp1 = 0 ;
47726 int res1 = 0 ;
47727 size_t val2 ;
47728 int ecode2 = 0 ;
47729 int res3 = 0 ;
47730 PyObject * obj0 = 0 ;
47731 PyObject * obj1 = 0 ;
47732 PyObject * obj2 = 0 ;
47733 char * kwnames[] = {
47734 (char *) "self",(char *) "index",(char *) "item", NULL
47735 };
47736
47737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47739 if (!SWIG_IsOK(res1)) {
47740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47741 }
47742 arg1 = reinterpret_cast< wxSizer * >(argp1);
47743 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47744 if (!SWIG_IsOK(ecode2)) {
47745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47746 }
47747 arg2 = static_cast< size_t >(val2);
47748 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47749 if (!SWIG_IsOK(res3)) {
47750 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47751 }
47752 {
47753 PyThreadState* __tstate = wxPyBeginAllowThreads();
47754 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47755 wxPyEndAllowThreads(__tstate);
47756 if (PyErr_Occurred()) SWIG_fail;
47757 }
47758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47759 return resultobj;
47760 fail:
47761 return NULL;
47762 }
47763
47764
47765 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47766 PyObject *resultobj = 0;
47767 wxSizer *arg1 = (wxSizer *) 0 ;
47768 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47769 wxSizerItem *result = 0 ;
47770 void *argp1 = 0 ;
47771 int res1 = 0 ;
47772 int res2 = 0 ;
47773 PyObject * obj0 = 0 ;
47774 PyObject * obj1 = 0 ;
47775 char * kwnames[] = {
47776 (char *) "self",(char *) "item", NULL
47777 };
47778
47779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47781 if (!SWIG_IsOK(res1)) {
47782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47783 }
47784 arg1 = reinterpret_cast< wxSizer * >(argp1);
47785 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47786 if (!SWIG_IsOK(res2)) {
47787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47788 }
47789 {
47790 PyThreadState* __tstate = wxPyBeginAllowThreads();
47791 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47792 wxPyEndAllowThreads(__tstate);
47793 if (PyErr_Occurred()) SWIG_fail;
47794 }
47795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47796 return resultobj;
47797 fail:
47798 return NULL;
47799 }
47800
47801
47802 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47803 PyObject *resultobj = 0;
47804 wxSizer *arg1 = (wxSizer *) 0 ;
47805 int arg2 ;
47806 int arg3 ;
47807 int arg4 ;
47808 int arg5 ;
47809 void *argp1 = 0 ;
47810 int res1 = 0 ;
47811 int val2 ;
47812 int ecode2 = 0 ;
47813 int val3 ;
47814 int ecode3 = 0 ;
47815 int val4 ;
47816 int ecode4 = 0 ;
47817 int val5 ;
47818 int ecode5 = 0 ;
47819 PyObject * obj0 = 0 ;
47820 PyObject * obj1 = 0 ;
47821 PyObject * obj2 = 0 ;
47822 PyObject * obj3 = 0 ;
47823 PyObject * obj4 = 0 ;
47824 char * kwnames[] = {
47825 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47826 };
47827
47828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47830 if (!SWIG_IsOK(res1)) {
47831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47832 }
47833 arg1 = reinterpret_cast< wxSizer * >(argp1);
47834 ecode2 = SWIG_AsVal_int(obj1, &val2);
47835 if (!SWIG_IsOK(ecode2)) {
47836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47837 }
47838 arg2 = static_cast< int >(val2);
47839 ecode3 = SWIG_AsVal_int(obj2, &val3);
47840 if (!SWIG_IsOK(ecode3)) {
47841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47842 }
47843 arg3 = static_cast< int >(val3);
47844 ecode4 = SWIG_AsVal_int(obj3, &val4);
47845 if (!SWIG_IsOK(ecode4)) {
47846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47847 }
47848 arg4 = static_cast< int >(val4);
47849 ecode5 = SWIG_AsVal_int(obj4, &val5);
47850 if (!SWIG_IsOK(ecode5)) {
47851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47852 }
47853 arg5 = static_cast< int >(val5);
47854 {
47855 PyThreadState* __tstate = wxPyBeginAllowThreads();
47856 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47857 wxPyEndAllowThreads(__tstate);
47858 if (PyErr_Occurred()) SWIG_fail;
47859 }
47860 resultobj = SWIG_Py_Void();
47861 return resultobj;
47862 fail:
47863 return NULL;
47864 }
47865
47866
47867 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47868 PyObject *resultobj = 0;
47869 wxSizer *arg1 = (wxSizer *) 0 ;
47870 wxSize *arg2 = 0 ;
47871 void *argp1 = 0 ;
47872 int res1 = 0 ;
47873 wxSize temp2 ;
47874 PyObject * obj0 = 0 ;
47875 PyObject * obj1 = 0 ;
47876 char * kwnames[] = {
47877 (char *) "self",(char *) "size", NULL
47878 };
47879
47880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47882 if (!SWIG_IsOK(res1)) {
47883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47884 }
47885 arg1 = reinterpret_cast< wxSizer * >(argp1);
47886 {
47887 arg2 = &temp2;
47888 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47889 }
47890 {
47891 PyThreadState* __tstate = wxPyBeginAllowThreads();
47892 (arg1)->SetMinSize((wxSize const &)*arg2);
47893 wxPyEndAllowThreads(__tstate);
47894 if (PyErr_Occurred()) SWIG_fail;
47895 }
47896 resultobj = SWIG_Py_Void();
47897 return resultobj;
47898 fail:
47899 return NULL;
47900 }
47901
47902
47903 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47904 PyObject *resultobj = 0;
47905 wxSizer *arg1 = (wxSizer *) 0 ;
47906 wxSize result;
47907 void *argp1 = 0 ;
47908 int res1 = 0 ;
47909 PyObject *swig_obj[1] ;
47910
47911 if (!args) SWIG_fail;
47912 swig_obj[0] = args;
47913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47914 if (!SWIG_IsOK(res1)) {
47915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47916 }
47917 arg1 = reinterpret_cast< wxSizer * >(argp1);
47918 {
47919 PyThreadState* __tstate = wxPyBeginAllowThreads();
47920 result = (arg1)->GetSize();
47921 wxPyEndAllowThreads(__tstate);
47922 if (PyErr_Occurred()) SWIG_fail;
47923 }
47924 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47925 return resultobj;
47926 fail:
47927 return NULL;
47928 }
47929
47930
47931 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47932 PyObject *resultobj = 0;
47933 wxSizer *arg1 = (wxSizer *) 0 ;
47934 wxPoint result;
47935 void *argp1 = 0 ;
47936 int res1 = 0 ;
47937 PyObject *swig_obj[1] ;
47938
47939 if (!args) SWIG_fail;
47940 swig_obj[0] = args;
47941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47942 if (!SWIG_IsOK(res1)) {
47943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47944 }
47945 arg1 = reinterpret_cast< wxSizer * >(argp1);
47946 {
47947 PyThreadState* __tstate = wxPyBeginAllowThreads();
47948 result = (arg1)->GetPosition();
47949 wxPyEndAllowThreads(__tstate);
47950 if (PyErr_Occurred()) SWIG_fail;
47951 }
47952 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47953 return resultobj;
47954 fail:
47955 return NULL;
47956 }
47957
47958
47959 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47960 PyObject *resultobj = 0;
47961 wxSizer *arg1 = (wxSizer *) 0 ;
47962 wxSize result;
47963 void *argp1 = 0 ;
47964 int res1 = 0 ;
47965 PyObject *swig_obj[1] ;
47966
47967 if (!args) SWIG_fail;
47968 swig_obj[0] = args;
47969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47970 if (!SWIG_IsOK(res1)) {
47971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47972 }
47973 arg1 = reinterpret_cast< wxSizer * >(argp1);
47974 {
47975 PyThreadState* __tstate = wxPyBeginAllowThreads();
47976 result = (arg1)->GetMinSize();
47977 wxPyEndAllowThreads(__tstate);
47978 if (PyErr_Occurred()) SWIG_fail;
47979 }
47980 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47981 return resultobj;
47982 fail:
47983 return NULL;
47984 }
47985
47986
47987 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47988 PyObject *resultobj = 0;
47989 wxSizer *arg1 = (wxSizer *) 0 ;
47990 void *argp1 = 0 ;
47991 int res1 = 0 ;
47992 PyObject *swig_obj[1] ;
47993
47994 if (!args) SWIG_fail;
47995 swig_obj[0] = args;
47996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47997 if (!SWIG_IsOK(res1)) {
47998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47999 }
48000 arg1 = reinterpret_cast< wxSizer * >(argp1);
48001 {
48002 PyThreadState* __tstate = wxPyBeginAllowThreads();
48003 (arg1)->RecalcSizes();
48004 wxPyEndAllowThreads(__tstate);
48005 if (PyErr_Occurred()) SWIG_fail;
48006 }
48007 resultobj = SWIG_Py_Void();
48008 return resultobj;
48009 fail:
48010 return NULL;
48011 }
48012
48013
48014 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48015 PyObject *resultobj = 0;
48016 wxSizer *arg1 = (wxSizer *) 0 ;
48017 wxSize result;
48018 void *argp1 = 0 ;
48019 int res1 = 0 ;
48020 PyObject *swig_obj[1] ;
48021
48022 if (!args) SWIG_fail;
48023 swig_obj[0] = args;
48024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48025 if (!SWIG_IsOK(res1)) {
48026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48027 }
48028 arg1 = reinterpret_cast< wxSizer * >(argp1);
48029 {
48030 PyThreadState* __tstate = wxPyBeginAllowThreads();
48031 result = (arg1)->CalcMin();
48032 wxPyEndAllowThreads(__tstate);
48033 if (PyErr_Occurred()) SWIG_fail;
48034 }
48035 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48036 return resultobj;
48037 fail:
48038 return NULL;
48039 }
48040
48041
48042 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48043 PyObject *resultobj = 0;
48044 wxSizer *arg1 = (wxSizer *) 0 ;
48045 void *argp1 = 0 ;
48046 int res1 = 0 ;
48047 PyObject *swig_obj[1] ;
48048
48049 if (!args) SWIG_fail;
48050 swig_obj[0] = args;
48051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48052 if (!SWIG_IsOK(res1)) {
48053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48054 }
48055 arg1 = reinterpret_cast< wxSizer * >(argp1);
48056 {
48057 PyThreadState* __tstate = wxPyBeginAllowThreads();
48058 (arg1)->Layout();
48059 wxPyEndAllowThreads(__tstate);
48060 if (PyErr_Occurred()) SWIG_fail;
48061 }
48062 resultobj = SWIG_Py_Void();
48063 return resultobj;
48064 fail:
48065 return NULL;
48066 }
48067
48068
48069 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48070 PyObject *resultobj = 0;
48071 wxSizer *arg1 = (wxSizer *) 0 ;
48072 wxWindow *arg2 = (wxWindow *) 0 ;
48073 wxSize result;
48074 void *argp1 = 0 ;
48075 int res1 = 0 ;
48076 void *argp2 = 0 ;
48077 int res2 = 0 ;
48078 PyObject * obj0 = 0 ;
48079 PyObject * obj1 = 0 ;
48080 char * kwnames[] = {
48081 (char *) "self",(char *) "window", NULL
48082 };
48083
48084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48086 if (!SWIG_IsOK(res1)) {
48087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48088 }
48089 arg1 = reinterpret_cast< wxSizer * >(argp1);
48090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48091 if (!SWIG_IsOK(res2)) {
48092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48093 }
48094 arg2 = reinterpret_cast< wxWindow * >(argp2);
48095 {
48096 PyThreadState* __tstate = wxPyBeginAllowThreads();
48097 result = (arg1)->Fit(arg2);
48098 wxPyEndAllowThreads(__tstate);
48099 if (PyErr_Occurred()) SWIG_fail;
48100 }
48101 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48102 return resultobj;
48103 fail:
48104 return NULL;
48105 }
48106
48107
48108 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48109 PyObject *resultobj = 0;
48110 wxSizer *arg1 = (wxSizer *) 0 ;
48111 wxWindow *arg2 = (wxWindow *) 0 ;
48112 void *argp1 = 0 ;
48113 int res1 = 0 ;
48114 void *argp2 = 0 ;
48115 int res2 = 0 ;
48116 PyObject * obj0 = 0 ;
48117 PyObject * obj1 = 0 ;
48118 char * kwnames[] = {
48119 (char *) "self",(char *) "window", NULL
48120 };
48121
48122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48124 if (!SWIG_IsOK(res1)) {
48125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48126 }
48127 arg1 = reinterpret_cast< wxSizer * >(argp1);
48128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48129 if (!SWIG_IsOK(res2)) {
48130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48131 }
48132 arg2 = reinterpret_cast< wxWindow * >(argp2);
48133 {
48134 PyThreadState* __tstate = wxPyBeginAllowThreads();
48135 (arg1)->FitInside(arg2);
48136 wxPyEndAllowThreads(__tstate);
48137 if (PyErr_Occurred()) SWIG_fail;
48138 }
48139 resultobj = SWIG_Py_Void();
48140 return resultobj;
48141 fail:
48142 return NULL;
48143 }
48144
48145
48146 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48147 PyObject *resultobj = 0;
48148 wxSizer *arg1 = (wxSizer *) 0 ;
48149 wxWindow *arg2 = (wxWindow *) 0 ;
48150 void *argp1 = 0 ;
48151 int res1 = 0 ;
48152 void *argp2 = 0 ;
48153 int res2 = 0 ;
48154 PyObject * obj0 = 0 ;
48155 PyObject * obj1 = 0 ;
48156 char * kwnames[] = {
48157 (char *) "self",(char *) "window", NULL
48158 };
48159
48160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48162 if (!SWIG_IsOK(res1)) {
48163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48164 }
48165 arg1 = reinterpret_cast< wxSizer * >(argp1);
48166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48167 if (!SWIG_IsOK(res2)) {
48168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48169 }
48170 arg2 = reinterpret_cast< wxWindow * >(argp2);
48171 {
48172 PyThreadState* __tstate = wxPyBeginAllowThreads();
48173 (arg1)->SetSizeHints(arg2);
48174 wxPyEndAllowThreads(__tstate);
48175 if (PyErr_Occurred()) SWIG_fail;
48176 }
48177 resultobj = SWIG_Py_Void();
48178 return resultobj;
48179 fail:
48180 return NULL;
48181 }
48182
48183
48184 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48185 PyObject *resultobj = 0;
48186 wxSizer *arg1 = (wxSizer *) 0 ;
48187 wxWindow *arg2 = (wxWindow *) 0 ;
48188 void *argp1 = 0 ;
48189 int res1 = 0 ;
48190 void *argp2 = 0 ;
48191 int res2 = 0 ;
48192 PyObject * obj0 = 0 ;
48193 PyObject * obj1 = 0 ;
48194 char * kwnames[] = {
48195 (char *) "self",(char *) "window", NULL
48196 };
48197
48198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48200 if (!SWIG_IsOK(res1)) {
48201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48202 }
48203 arg1 = reinterpret_cast< wxSizer * >(argp1);
48204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48205 if (!SWIG_IsOK(res2)) {
48206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48207 }
48208 arg2 = reinterpret_cast< wxWindow * >(argp2);
48209 {
48210 PyThreadState* __tstate = wxPyBeginAllowThreads();
48211 (arg1)->SetVirtualSizeHints(arg2);
48212 wxPyEndAllowThreads(__tstate);
48213 if (PyErr_Occurred()) SWIG_fail;
48214 }
48215 resultobj = SWIG_Py_Void();
48216 return resultobj;
48217 fail:
48218 return NULL;
48219 }
48220
48221
48222 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48223 PyObject *resultobj = 0;
48224 wxSizer *arg1 = (wxSizer *) 0 ;
48225 bool arg2 = (bool) false ;
48226 void *argp1 = 0 ;
48227 int res1 = 0 ;
48228 bool val2 ;
48229 int ecode2 = 0 ;
48230 PyObject * obj0 = 0 ;
48231 PyObject * obj1 = 0 ;
48232 char * kwnames[] = {
48233 (char *) "self",(char *) "deleteWindows", NULL
48234 };
48235
48236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48238 if (!SWIG_IsOK(res1)) {
48239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48240 }
48241 arg1 = reinterpret_cast< wxSizer * >(argp1);
48242 if (obj1) {
48243 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48244 if (!SWIG_IsOK(ecode2)) {
48245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48246 }
48247 arg2 = static_cast< bool >(val2);
48248 }
48249 {
48250 PyThreadState* __tstate = wxPyBeginAllowThreads();
48251 (arg1)->Clear(arg2);
48252 wxPyEndAllowThreads(__tstate);
48253 if (PyErr_Occurred()) SWIG_fail;
48254 }
48255 resultobj = SWIG_Py_Void();
48256 return resultobj;
48257 fail:
48258 return NULL;
48259 }
48260
48261
48262 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48263 PyObject *resultobj = 0;
48264 wxSizer *arg1 = (wxSizer *) 0 ;
48265 void *argp1 = 0 ;
48266 int res1 = 0 ;
48267 PyObject *swig_obj[1] ;
48268
48269 if (!args) SWIG_fail;
48270 swig_obj[0] = args;
48271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48272 if (!SWIG_IsOK(res1)) {
48273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48274 }
48275 arg1 = reinterpret_cast< wxSizer * >(argp1);
48276 {
48277 PyThreadState* __tstate = wxPyBeginAllowThreads();
48278 (arg1)->DeleteWindows();
48279 wxPyEndAllowThreads(__tstate);
48280 if (PyErr_Occurred()) SWIG_fail;
48281 }
48282 resultobj = SWIG_Py_Void();
48283 return resultobj;
48284 fail:
48285 return NULL;
48286 }
48287
48288
48289 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48290 PyObject *resultobj = 0;
48291 wxSizer *arg1 = (wxSizer *) 0 ;
48292 PyObject *result = 0 ;
48293 void *argp1 = 0 ;
48294 int res1 = 0 ;
48295 PyObject *swig_obj[1] ;
48296
48297 if (!args) SWIG_fail;
48298 swig_obj[0] = args;
48299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48300 if (!SWIG_IsOK(res1)) {
48301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48302 }
48303 arg1 = reinterpret_cast< wxSizer * >(argp1);
48304 {
48305 PyThreadState* __tstate = wxPyBeginAllowThreads();
48306 result = (PyObject *)wxSizer_GetChildren(arg1);
48307 wxPyEndAllowThreads(__tstate);
48308 if (PyErr_Occurred()) SWIG_fail;
48309 }
48310 resultobj = result;
48311 return resultobj;
48312 fail:
48313 return NULL;
48314 }
48315
48316
48317 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48318 PyObject *resultobj = 0;
48319 wxSizer *arg1 = (wxSizer *) 0 ;
48320 PyObject *arg2 = (PyObject *) 0 ;
48321 bool arg3 = (bool) true ;
48322 bool arg4 = (bool) false ;
48323 bool result;
48324 void *argp1 = 0 ;
48325 int res1 = 0 ;
48326 bool val3 ;
48327 int ecode3 = 0 ;
48328 bool val4 ;
48329 int ecode4 = 0 ;
48330 PyObject * obj0 = 0 ;
48331 PyObject * obj1 = 0 ;
48332 PyObject * obj2 = 0 ;
48333 PyObject * obj3 = 0 ;
48334 char * kwnames[] = {
48335 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48336 };
48337
48338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48340 if (!SWIG_IsOK(res1)) {
48341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48342 }
48343 arg1 = reinterpret_cast< wxSizer * >(argp1);
48344 arg2 = obj1;
48345 if (obj2) {
48346 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48347 if (!SWIG_IsOK(ecode3)) {
48348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48349 }
48350 arg3 = static_cast< bool >(val3);
48351 }
48352 if (obj3) {
48353 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48354 if (!SWIG_IsOK(ecode4)) {
48355 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48356 }
48357 arg4 = static_cast< bool >(val4);
48358 }
48359 {
48360 PyThreadState* __tstate = wxPyBeginAllowThreads();
48361 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48362 wxPyEndAllowThreads(__tstate);
48363 if (PyErr_Occurred()) SWIG_fail;
48364 }
48365 {
48366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48367 }
48368 return resultobj;
48369 fail:
48370 return NULL;
48371 }
48372
48373
48374 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48375 PyObject *resultobj = 0;
48376 wxSizer *arg1 = (wxSizer *) 0 ;
48377 PyObject *arg2 = (PyObject *) 0 ;
48378 bool result;
48379 void *argp1 = 0 ;
48380 int res1 = 0 ;
48381 PyObject * obj0 = 0 ;
48382 PyObject * obj1 = 0 ;
48383 char * kwnames[] = {
48384 (char *) "self",(char *) "item", NULL
48385 };
48386
48387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48389 if (!SWIG_IsOK(res1)) {
48390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48391 }
48392 arg1 = reinterpret_cast< wxSizer * >(argp1);
48393 arg2 = obj1;
48394 {
48395 PyThreadState* __tstate = wxPyBeginAllowThreads();
48396 result = (bool)wxSizer_IsShown(arg1,arg2);
48397 wxPyEndAllowThreads(__tstate);
48398 if (PyErr_Occurred()) SWIG_fail;
48399 }
48400 {
48401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48402 }
48403 return resultobj;
48404 fail:
48405 return NULL;
48406 }
48407
48408
48409 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48410 PyObject *resultobj = 0;
48411 wxSizer *arg1 = (wxSizer *) 0 ;
48412 bool arg2 ;
48413 void *argp1 = 0 ;
48414 int res1 = 0 ;
48415 bool val2 ;
48416 int ecode2 = 0 ;
48417 PyObject * obj0 = 0 ;
48418 PyObject * obj1 = 0 ;
48419 char * kwnames[] = {
48420 (char *) "self",(char *) "show", NULL
48421 };
48422
48423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48425 if (!SWIG_IsOK(res1)) {
48426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48427 }
48428 arg1 = reinterpret_cast< wxSizer * >(argp1);
48429 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48430 if (!SWIG_IsOK(ecode2)) {
48431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48432 }
48433 arg2 = static_cast< bool >(val2);
48434 {
48435 PyThreadState* __tstate = wxPyBeginAllowThreads();
48436 (arg1)->ShowItems(arg2);
48437 wxPyEndAllowThreads(__tstate);
48438 if (PyErr_Occurred()) SWIG_fail;
48439 }
48440 resultobj = SWIG_Py_Void();
48441 return resultobj;
48442 fail:
48443 return NULL;
48444 }
48445
48446
48447 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48448 PyObject *obj;
48449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48450 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48451 return SWIG_Py_Void();
48452 }
48453
48454 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48455 PyObject *resultobj = 0;
48456 wxPySizer *result = 0 ;
48457
48458 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48459 {
48460 PyThreadState* __tstate = wxPyBeginAllowThreads();
48461 result = (wxPySizer *)new wxPySizer();
48462 wxPyEndAllowThreads(__tstate);
48463 if (PyErr_Occurred()) SWIG_fail;
48464 }
48465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48466 return resultobj;
48467 fail:
48468 return NULL;
48469 }
48470
48471
48472 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48473 PyObject *resultobj = 0;
48474 wxPySizer *arg1 = (wxPySizer *) 0 ;
48475 PyObject *arg2 = (PyObject *) 0 ;
48476 PyObject *arg3 = (PyObject *) 0 ;
48477 void *argp1 = 0 ;
48478 int res1 = 0 ;
48479 PyObject * obj0 = 0 ;
48480 PyObject * obj1 = 0 ;
48481 PyObject * obj2 = 0 ;
48482 char * kwnames[] = {
48483 (char *) "self",(char *) "self",(char *) "_class", NULL
48484 };
48485
48486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48488 if (!SWIG_IsOK(res1)) {
48489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48490 }
48491 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48492 arg2 = obj1;
48493 arg3 = obj2;
48494 {
48495 PyThreadState* __tstate = wxPyBeginAllowThreads();
48496 (arg1)->_setCallbackInfo(arg2,arg3);
48497 wxPyEndAllowThreads(__tstate);
48498 if (PyErr_Occurred()) SWIG_fail;
48499 }
48500 resultobj = SWIG_Py_Void();
48501 return resultobj;
48502 fail:
48503 return NULL;
48504 }
48505
48506
48507 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48508 PyObject *obj;
48509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48510 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48511 return SWIG_Py_Void();
48512 }
48513
48514 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48515 return SWIG_Python_InitShadowInstance(args);
48516 }
48517
48518 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48519 PyObject *resultobj = 0;
48520 int arg1 = (int) wxHORIZONTAL ;
48521 wxBoxSizer *result = 0 ;
48522 int val1 ;
48523 int ecode1 = 0 ;
48524 PyObject * obj0 = 0 ;
48525 char * kwnames[] = {
48526 (char *) "orient", NULL
48527 };
48528
48529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48530 if (obj0) {
48531 ecode1 = SWIG_AsVal_int(obj0, &val1);
48532 if (!SWIG_IsOK(ecode1)) {
48533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48534 }
48535 arg1 = static_cast< int >(val1);
48536 }
48537 {
48538 PyThreadState* __tstate = wxPyBeginAllowThreads();
48539 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48540 wxPyEndAllowThreads(__tstate);
48541 if (PyErr_Occurred()) SWIG_fail;
48542 }
48543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48544 return resultobj;
48545 fail:
48546 return NULL;
48547 }
48548
48549
48550 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48551 PyObject *resultobj = 0;
48552 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48553 int result;
48554 void *argp1 = 0 ;
48555 int res1 = 0 ;
48556 PyObject *swig_obj[1] ;
48557
48558 if (!args) SWIG_fail;
48559 swig_obj[0] = args;
48560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48561 if (!SWIG_IsOK(res1)) {
48562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48563 }
48564 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48565 {
48566 PyThreadState* __tstate = wxPyBeginAllowThreads();
48567 result = (int)(arg1)->GetOrientation();
48568 wxPyEndAllowThreads(__tstate);
48569 if (PyErr_Occurred()) SWIG_fail;
48570 }
48571 resultobj = SWIG_From_int(static_cast< int >(result));
48572 return resultobj;
48573 fail:
48574 return NULL;
48575 }
48576
48577
48578 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48579 PyObject *resultobj = 0;
48580 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48581 int arg2 ;
48582 void *argp1 = 0 ;
48583 int res1 = 0 ;
48584 int val2 ;
48585 int ecode2 = 0 ;
48586 PyObject * obj0 = 0 ;
48587 PyObject * obj1 = 0 ;
48588 char * kwnames[] = {
48589 (char *) "self",(char *) "orient", NULL
48590 };
48591
48592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48594 if (!SWIG_IsOK(res1)) {
48595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48596 }
48597 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48598 ecode2 = SWIG_AsVal_int(obj1, &val2);
48599 if (!SWIG_IsOK(ecode2)) {
48600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48601 }
48602 arg2 = static_cast< int >(val2);
48603 {
48604 PyThreadState* __tstate = wxPyBeginAllowThreads();
48605 (arg1)->SetOrientation(arg2);
48606 wxPyEndAllowThreads(__tstate);
48607 if (PyErr_Occurred()) SWIG_fail;
48608 }
48609 resultobj = SWIG_Py_Void();
48610 return resultobj;
48611 fail:
48612 return NULL;
48613 }
48614
48615
48616 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48617 PyObject *obj;
48618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48619 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48620 return SWIG_Py_Void();
48621 }
48622
48623 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48624 return SWIG_Python_InitShadowInstance(args);
48625 }
48626
48627 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48628 PyObject *resultobj = 0;
48629 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48630 int arg2 = (int) wxHORIZONTAL ;
48631 wxStaticBoxSizer *result = 0 ;
48632 void *argp1 = 0 ;
48633 int res1 = 0 ;
48634 int val2 ;
48635 int ecode2 = 0 ;
48636 PyObject * obj0 = 0 ;
48637 PyObject * obj1 = 0 ;
48638 char * kwnames[] = {
48639 (char *) "box",(char *) "orient", NULL
48640 };
48641
48642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48644 if (!SWIG_IsOK(res1)) {
48645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48646 }
48647 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48648 if (obj1) {
48649 ecode2 = SWIG_AsVal_int(obj1, &val2);
48650 if (!SWIG_IsOK(ecode2)) {
48651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48652 }
48653 arg2 = static_cast< int >(val2);
48654 }
48655 {
48656 PyThreadState* __tstate = wxPyBeginAllowThreads();
48657 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48658 wxPyEndAllowThreads(__tstate);
48659 if (PyErr_Occurred()) SWIG_fail;
48660 }
48661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48662 return resultobj;
48663 fail:
48664 return NULL;
48665 }
48666
48667
48668 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48669 PyObject *resultobj = 0;
48670 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48671 wxStaticBox *result = 0 ;
48672 void *argp1 = 0 ;
48673 int res1 = 0 ;
48674 PyObject *swig_obj[1] ;
48675
48676 if (!args) SWIG_fail;
48677 swig_obj[0] = args;
48678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48679 if (!SWIG_IsOK(res1)) {
48680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48681 }
48682 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48683 {
48684 PyThreadState* __tstate = wxPyBeginAllowThreads();
48685 result = (wxStaticBox *)(arg1)->GetStaticBox();
48686 wxPyEndAllowThreads(__tstate);
48687 if (PyErr_Occurred()) SWIG_fail;
48688 }
48689 {
48690 resultobj = wxPyMake_wxObject(result, (bool)0);
48691 }
48692 return resultobj;
48693 fail:
48694 return NULL;
48695 }
48696
48697
48698 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48699 PyObject *obj;
48700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48701 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48702 return SWIG_Py_Void();
48703 }
48704
48705 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48706 return SWIG_Python_InitShadowInstance(args);
48707 }
48708
48709 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48710 PyObject *resultobj = 0;
48711 int arg1 = (int) 1 ;
48712 int arg2 = (int) 0 ;
48713 int arg3 = (int) 0 ;
48714 int arg4 = (int) 0 ;
48715 wxGridSizer *result = 0 ;
48716 int val1 ;
48717 int ecode1 = 0 ;
48718 int val2 ;
48719 int ecode2 = 0 ;
48720 int val3 ;
48721 int ecode3 = 0 ;
48722 int val4 ;
48723 int ecode4 = 0 ;
48724 PyObject * obj0 = 0 ;
48725 PyObject * obj1 = 0 ;
48726 PyObject * obj2 = 0 ;
48727 PyObject * obj3 = 0 ;
48728 char * kwnames[] = {
48729 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48730 };
48731
48732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48733 if (obj0) {
48734 ecode1 = SWIG_AsVal_int(obj0, &val1);
48735 if (!SWIG_IsOK(ecode1)) {
48736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48737 }
48738 arg1 = static_cast< int >(val1);
48739 }
48740 if (obj1) {
48741 ecode2 = SWIG_AsVal_int(obj1, &val2);
48742 if (!SWIG_IsOK(ecode2)) {
48743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48744 }
48745 arg2 = static_cast< int >(val2);
48746 }
48747 if (obj2) {
48748 ecode3 = SWIG_AsVal_int(obj2, &val3);
48749 if (!SWIG_IsOK(ecode3)) {
48750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48751 }
48752 arg3 = static_cast< int >(val3);
48753 }
48754 if (obj3) {
48755 ecode4 = SWIG_AsVal_int(obj3, &val4);
48756 if (!SWIG_IsOK(ecode4)) {
48757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48758 }
48759 arg4 = static_cast< int >(val4);
48760 }
48761 {
48762 PyThreadState* __tstate = wxPyBeginAllowThreads();
48763 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48764 wxPyEndAllowThreads(__tstate);
48765 if (PyErr_Occurred()) SWIG_fail;
48766 }
48767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48768 return resultobj;
48769 fail:
48770 return NULL;
48771 }
48772
48773
48774 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48775 PyObject *resultobj = 0;
48776 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48777 int arg2 ;
48778 void *argp1 = 0 ;
48779 int res1 = 0 ;
48780 int val2 ;
48781 int ecode2 = 0 ;
48782 PyObject * obj0 = 0 ;
48783 PyObject * obj1 = 0 ;
48784 char * kwnames[] = {
48785 (char *) "self",(char *) "cols", NULL
48786 };
48787
48788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48790 if (!SWIG_IsOK(res1)) {
48791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48792 }
48793 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48794 ecode2 = SWIG_AsVal_int(obj1, &val2);
48795 if (!SWIG_IsOK(ecode2)) {
48796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48797 }
48798 arg2 = static_cast< int >(val2);
48799 {
48800 PyThreadState* __tstate = wxPyBeginAllowThreads();
48801 (arg1)->SetCols(arg2);
48802 wxPyEndAllowThreads(__tstate);
48803 if (PyErr_Occurred()) SWIG_fail;
48804 }
48805 resultobj = SWIG_Py_Void();
48806 return resultobj;
48807 fail:
48808 return NULL;
48809 }
48810
48811
48812 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48813 PyObject *resultobj = 0;
48814 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48815 int arg2 ;
48816 void *argp1 = 0 ;
48817 int res1 = 0 ;
48818 int val2 ;
48819 int ecode2 = 0 ;
48820 PyObject * obj0 = 0 ;
48821 PyObject * obj1 = 0 ;
48822 char * kwnames[] = {
48823 (char *) "self",(char *) "rows", NULL
48824 };
48825
48826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48828 if (!SWIG_IsOK(res1)) {
48829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48830 }
48831 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48832 ecode2 = SWIG_AsVal_int(obj1, &val2);
48833 if (!SWIG_IsOK(ecode2)) {
48834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48835 }
48836 arg2 = static_cast< int >(val2);
48837 {
48838 PyThreadState* __tstate = wxPyBeginAllowThreads();
48839 (arg1)->SetRows(arg2);
48840 wxPyEndAllowThreads(__tstate);
48841 if (PyErr_Occurred()) SWIG_fail;
48842 }
48843 resultobj = SWIG_Py_Void();
48844 return resultobj;
48845 fail:
48846 return NULL;
48847 }
48848
48849
48850 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48851 PyObject *resultobj = 0;
48852 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48853 int arg2 ;
48854 void *argp1 = 0 ;
48855 int res1 = 0 ;
48856 int val2 ;
48857 int ecode2 = 0 ;
48858 PyObject * obj0 = 0 ;
48859 PyObject * obj1 = 0 ;
48860 char * kwnames[] = {
48861 (char *) "self",(char *) "gap", NULL
48862 };
48863
48864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48866 if (!SWIG_IsOK(res1)) {
48867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48868 }
48869 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48870 ecode2 = SWIG_AsVal_int(obj1, &val2);
48871 if (!SWIG_IsOK(ecode2)) {
48872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48873 }
48874 arg2 = static_cast< int >(val2);
48875 {
48876 PyThreadState* __tstate = wxPyBeginAllowThreads();
48877 (arg1)->SetVGap(arg2);
48878 wxPyEndAllowThreads(__tstate);
48879 if (PyErr_Occurred()) SWIG_fail;
48880 }
48881 resultobj = SWIG_Py_Void();
48882 return resultobj;
48883 fail:
48884 return NULL;
48885 }
48886
48887
48888 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48889 PyObject *resultobj = 0;
48890 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48891 int arg2 ;
48892 void *argp1 = 0 ;
48893 int res1 = 0 ;
48894 int val2 ;
48895 int ecode2 = 0 ;
48896 PyObject * obj0 = 0 ;
48897 PyObject * obj1 = 0 ;
48898 char * kwnames[] = {
48899 (char *) "self",(char *) "gap", NULL
48900 };
48901
48902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48904 if (!SWIG_IsOK(res1)) {
48905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48906 }
48907 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48908 ecode2 = SWIG_AsVal_int(obj1, &val2);
48909 if (!SWIG_IsOK(ecode2)) {
48910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48911 }
48912 arg2 = static_cast< int >(val2);
48913 {
48914 PyThreadState* __tstate = wxPyBeginAllowThreads();
48915 (arg1)->SetHGap(arg2);
48916 wxPyEndAllowThreads(__tstate);
48917 if (PyErr_Occurred()) SWIG_fail;
48918 }
48919 resultobj = SWIG_Py_Void();
48920 return resultobj;
48921 fail:
48922 return NULL;
48923 }
48924
48925
48926 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48927 PyObject *resultobj = 0;
48928 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48929 int result;
48930 void *argp1 = 0 ;
48931 int res1 = 0 ;
48932 PyObject *swig_obj[1] ;
48933
48934 if (!args) SWIG_fail;
48935 swig_obj[0] = args;
48936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48937 if (!SWIG_IsOK(res1)) {
48938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48939 }
48940 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48941 {
48942 PyThreadState* __tstate = wxPyBeginAllowThreads();
48943 result = (int)(arg1)->GetCols();
48944 wxPyEndAllowThreads(__tstate);
48945 if (PyErr_Occurred()) SWIG_fail;
48946 }
48947 resultobj = SWIG_From_int(static_cast< int >(result));
48948 return resultobj;
48949 fail:
48950 return NULL;
48951 }
48952
48953
48954 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48955 PyObject *resultobj = 0;
48956 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48957 int result;
48958 void *argp1 = 0 ;
48959 int res1 = 0 ;
48960 PyObject *swig_obj[1] ;
48961
48962 if (!args) SWIG_fail;
48963 swig_obj[0] = args;
48964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48965 if (!SWIG_IsOK(res1)) {
48966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48967 }
48968 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48969 {
48970 PyThreadState* __tstate = wxPyBeginAllowThreads();
48971 result = (int)(arg1)->GetRows();
48972 wxPyEndAllowThreads(__tstate);
48973 if (PyErr_Occurred()) SWIG_fail;
48974 }
48975 resultobj = SWIG_From_int(static_cast< int >(result));
48976 return resultobj;
48977 fail:
48978 return NULL;
48979 }
48980
48981
48982 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48983 PyObject *resultobj = 0;
48984 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48985 int result;
48986 void *argp1 = 0 ;
48987 int res1 = 0 ;
48988 PyObject *swig_obj[1] ;
48989
48990 if (!args) SWIG_fail;
48991 swig_obj[0] = args;
48992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48993 if (!SWIG_IsOK(res1)) {
48994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48995 }
48996 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48997 {
48998 PyThreadState* __tstate = wxPyBeginAllowThreads();
48999 result = (int)(arg1)->GetVGap();
49000 wxPyEndAllowThreads(__tstate);
49001 if (PyErr_Occurred()) SWIG_fail;
49002 }
49003 resultobj = SWIG_From_int(static_cast< int >(result));
49004 return resultobj;
49005 fail:
49006 return NULL;
49007 }
49008
49009
49010 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49011 PyObject *resultobj = 0;
49012 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49013 int result;
49014 void *argp1 = 0 ;
49015 int res1 = 0 ;
49016 PyObject *swig_obj[1] ;
49017
49018 if (!args) SWIG_fail;
49019 swig_obj[0] = args;
49020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49021 if (!SWIG_IsOK(res1)) {
49022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49023 }
49024 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49025 {
49026 PyThreadState* __tstate = wxPyBeginAllowThreads();
49027 result = (int)(arg1)->GetHGap();
49028 wxPyEndAllowThreads(__tstate);
49029 if (PyErr_Occurred()) SWIG_fail;
49030 }
49031 resultobj = SWIG_From_int(static_cast< int >(result));
49032 return resultobj;
49033 fail:
49034 return NULL;
49035 }
49036
49037
49038 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49039 PyObject *obj;
49040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49041 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49042 return SWIG_Py_Void();
49043 }
49044
49045 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49046 return SWIG_Python_InitShadowInstance(args);
49047 }
49048
49049 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49050 PyObject *resultobj = 0;
49051 int arg1 = (int) 1 ;
49052 int arg2 = (int) 0 ;
49053 int arg3 = (int) 0 ;
49054 int arg4 = (int) 0 ;
49055 wxFlexGridSizer *result = 0 ;
49056 int val1 ;
49057 int ecode1 = 0 ;
49058 int val2 ;
49059 int ecode2 = 0 ;
49060 int val3 ;
49061 int ecode3 = 0 ;
49062 int val4 ;
49063 int ecode4 = 0 ;
49064 PyObject * obj0 = 0 ;
49065 PyObject * obj1 = 0 ;
49066 PyObject * obj2 = 0 ;
49067 PyObject * obj3 = 0 ;
49068 char * kwnames[] = {
49069 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49070 };
49071
49072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49073 if (obj0) {
49074 ecode1 = SWIG_AsVal_int(obj0, &val1);
49075 if (!SWIG_IsOK(ecode1)) {
49076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49077 }
49078 arg1 = static_cast< int >(val1);
49079 }
49080 if (obj1) {
49081 ecode2 = SWIG_AsVal_int(obj1, &val2);
49082 if (!SWIG_IsOK(ecode2)) {
49083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49084 }
49085 arg2 = static_cast< int >(val2);
49086 }
49087 if (obj2) {
49088 ecode3 = SWIG_AsVal_int(obj2, &val3);
49089 if (!SWIG_IsOK(ecode3)) {
49090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49091 }
49092 arg3 = static_cast< int >(val3);
49093 }
49094 if (obj3) {
49095 ecode4 = SWIG_AsVal_int(obj3, &val4);
49096 if (!SWIG_IsOK(ecode4)) {
49097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49098 }
49099 arg4 = static_cast< int >(val4);
49100 }
49101 {
49102 PyThreadState* __tstate = wxPyBeginAllowThreads();
49103 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49104 wxPyEndAllowThreads(__tstate);
49105 if (PyErr_Occurred()) SWIG_fail;
49106 }
49107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49108 return resultobj;
49109 fail:
49110 return NULL;
49111 }
49112
49113
49114 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49115 PyObject *resultobj = 0;
49116 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49117 size_t arg2 ;
49118 int arg3 = (int) 0 ;
49119 void *argp1 = 0 ;
49120 int res1 = 0 ;
49121 size_t val2 ;
49122 int ecode2 = 0 ;
49123 int val3 ;
49124 int ecode3 = 0 ;
49125 PyObject * obj0 = 0 ;
49126 PyObject * obj1 = 0 ;
49127 PyObject * obj2 = 0 ;
49128 char * kwnames[] = {
49129 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49130 };
49131
49132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49134 if (!SWIG_IsOK(res1)) {
49135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49136 }
49137 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49138 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49139 if (!SWIG_IsOK(ecode2)) {
49140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49141 }
49142 arg2 = static_cast< size_t >(val2);
49143 if (obj2) {
49144 ecode3 = SWIG_AsVal_int(obj2, &val3);
49145 if (!SWIG_IsOK(ecode3)) {
49146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49147 }
49148 arg3 = static_cast< int >(val3);
49149 }
49150 {
49151 PyThreadState* __tstate = wxPyBeginAllowThreads();
49152 (arg1)->AddGrowableRow(arg2,arg3);
49153 wxPyEndAllowThreads(__tstate);
49154 if (PyErr_Occurred()) SWIG_fail;
49155 }
49156 resultobj = SWIG_Py_Void();
49157 return resultobj;
49158 fail:
49159 return NULL;
49160 }
49161
49162
49163 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49164 PyObject *resultobj = 0;
49165 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49166 size_t arg2 ;
49167 void *argp1 = 0 ;
49168 int res1 = 0 ;
49169 size_t val2 ;
49170 int ecode2 = 0 ;
49171 PyObject * obj0 = 0 ;
49172 PyObject * obj1 = 0 ;
49173 char * kwnames[] = {
49174 (char *) "self",(char *) "idx", NULL
49175 };
49176
49177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49179 if (!SWIG_IsOK(res1)) {
49180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49181 }
49182 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49183 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49184 if (!SWIG_IsOK(ecode2)) {
49185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49186 }
49187 arg2 = static_cast< size_t >(val2);
49188 {
49189 PyThreadState* __tstate = wxPyBeginAllowThreads();
49190 (arg1)->RemoveGrowableRow(arg2);
49191 wxPyEndAllowThreads(__tstate);
49192 if (PyErr_Occurred()) SWIG_fail;
49193 }
49194 resultobj = SWIG_Py_Void();
49195 return resultobj;
49196 fail:
49197 return NULL;
49198 }
49199
49200
49201 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49202 PyObject *resultobj = 0;
49203 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49204 size_t arg2 ;
49205 int arg3 = (int) 0 ;
49206 void *argp1 = 0 ;
49207 int res1 = 0 ;
49208 size_t val2 ;
49209 int ecode2 = 0 ;
49210 int val3 ;
49211 int ecode3 = 0 ;
49212 PyObject * obj0 = 0 ;
49213 PyObject * obj1 = 0 ;
49214 PyObject * obj2 = 0 ;
49215 char * kwnames[] = {
49216 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49217 };
49218
49219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49221 if (!SWIG_IsOK(res1)) {
49222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49223 }
49224 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49225 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49226 if (!SWIG_IsOK(ecode2)) {
49227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49228 }
49229 arg2 = static_cast< size_t >(val2);
49230 if (obj2) {
49231 ecode3 = SWIG_AsVal_int(obj2, &val3);
49232 if (!SWIG_IsOK(ecode3)) {
49233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49234 }
49235 arg3 = static_cast< int >(val3);
49236 }
49237 {
49238 PyThreadState* __tstate = wxPyBeginAllowThreads();
49239 (arg1)->AddGrowableCol(arg2,arg3);
49240 wxPyEndAllowThreads(__tstate);
49241 if (PyErr_Occurred()) SWIG_fail;
49242 }
49243 resultobj = SWIG_Py_Void();
49244 return resultobj;
49245 fail:
49246 return NULL;
49247 }
49248
49249
49250 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49251 PyObject *resultobj = 0;
49252 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49253 size_t arg2 ;
49254 void *argp1 = 0 ;
49255 int res1 = 0 ;
49256 size_t val2 ;
49257 int ecode2 = 0 ;
49258 PyObject * obj0 = 0 ;
49259 PyObject * obj1 = 0 ;
49260 char * kwnames[] = {
49261 (char *) "self",(char *) "idx", NULL
49262 };
49263
49264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49266 if (!SWIG_IsOK(res1)) {
49267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49268 }
49269 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49270 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49271 if (!SWIG_IsOK(ecode2)) {
49272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49273 }
49274 arg2 = static_cast< size_t >(val2);
49275 {
49276 PyThreadState* __tstate = wxPyBeginAllowThreads();
49277 (arg1)->RemoveGrowableCol(arg2);
49278 wxPyEndAllowThreads(__tstate);
49279 if (PyErr_Occurred()) SWIG_fail;
49280 }
49281 resultobj = SWIG_Py_Void();
49282 return resultobj;
49283 fail:
49284 return NULL;
49285 }
49286
49287
49288 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49289 PyObject *resultobj = 0;
49290 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49291 int arg2 ;
49292 void *argp1 = 0 ;
49293 int res1 = 0 ;
49294 int val2 ;
49295 int ecode2 = 0 ;
49296 PyObject * obj0 = 0 ;
49297 PyObject * obj1 = 0 ;
49298 char * kwnames[] = {
49299 (char *) "self",(char *) "direction", NULL
49300 };
49301
49302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49304 if (!SWIG_IsOK(res1)) {
49305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49306 }
49307 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49308 ecode2 = SWIG_AsVal_int(obj1, &val2);
49309 if (!SWIG_IsOK(ecode2)) {
49310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49311 }
49312 arg2 = static_cast< int >(val2);
49313 {
49314 PyThreadState* __tstate = wxPyBeginAllowThreads();
49315 (arg1)->SetFlexibleDirection(arg2);
49316 wxPyEndAllowThreads(__tstate);
49317 if (PyErr_Occurred()) SWIG_fail;
49318 }
49319 resultobj = SWIG_Py_Void();
49320 return resultobj;
49321 fail:
49322 return NULL;
49323 }
49324
49325
49326 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49327 PyObject *resultobj = 0;
49328 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49329 int result;
49330 void *argp1 = 0 ;
49331 int res1 = 0 ;
49332 PyObject *swig_obj[1] ;
49333
49334 if (!args) SWIG_fail;
49335 swig_obj[0] = args;
49336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49337 if (!SWIG_IsOK(res1)) {
49338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49339 }
49340 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49341 {
49342 PyThreadState* __tstate = wxPyBeginAllowThreads();
49343 result = (int)(arg1)->GetFlexibleDirection();
49344 wxPyEndAllowThreads(__tstate);
49345 if (PyErr_Occurred()) SWIG_fail;
49346 }
49347 resultobj = SWIG_From_int(static_cast< int >(result));
49348 return resultobj;
49349 fail:
49350 return NULL;
49351 }
49352
49353
49354 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49355 PyObject *resultobj = 0;
49356 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49357 wxFlexSizerGrowMode arg2 ;
49358 void *argp1 = 0 ;
49359 int res1 = 0 ;
49360 int val2 ;
49361 int ecode2 = 0 ;
49362 PyObject * obj0 = 0 ;
49363 PyObject * obj1 = 0 ;
49364 char * kwnames[] = {
49365 (char *) "self",(char *) "mode", NULL
49366 };
49367
49368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49370 if (!SWIG_IsOK(res1)) {
49371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49372 }
49373 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49374 ecode2 = SWIG_AsVal_int(obj1, &val2);
49375 if (!SWIG_IsOK(ecode2)) {
49376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49377 }
49378 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49379 {
49380 PyThreadState* __tstate = wxPyBeginAllowThreads();
49381 (arg1)->SetNonFlexibleGrowMode(arg2);
49382 wxPyEndAllowThreads(__tstate);
49383 if (PyErr_Occurred()) SWIG_fail;
49384 }
49385 resultobj = SWIG_Py_Void();
49386 return resultobj;
49387 fail:
49388 return NULL;
49389 }
49390
49391
49392 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49393 PyObject *resultobj = 0;
49394 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49395 wxFlexSizerGrowMode result;
49396 void *argp1 = 0 ;
49397 int res1 = 0 ;
49398 PyObject *swig_obj[1] ;
49399
49400 if (!args) SWIG_fail;
49401 swig_obj[0] = args;
49402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49403 if (!SWIG_IsOK(res1)) {
49404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49405 }
49406 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49407 {
49408 PyThreadState* __tstate = wxPyBeginAllowThreads();
49409 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49410 wxPyEndAllowThreads(__tstate);
49411 if (PyErr_Occurred()) SWIG_fail;
49412 }
49413 resultobj = SWIG_From_int(static_cast< int >(result));
49414 return resultobj;
49415 fail:
49416 return NULL;
49417 }
49418
49419
49420 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49421 PyObject *resultobj = 0;
49422 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49423 wxArrayInt *result = 0 ;
49424 void *argp1 = 0 ;
49425 int res1 = 0 ;
49426 PyObject *swig_obj[1] ;
49427
49428 if (!args) SWIG_fail;
49429 swig_obj[0] = args;
49430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49431 if (!SWIG_IsOK(res1)) {
49432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49433 }
49434 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49435 {
49436 PyThreadState* __tstate = wxPyBeginAllowThreads();
49437 {
49438 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49439 result = (wxArrayInt *) &_result_ref;
49440 }
49441 wxPyEndAllowThreads(__tstate);
49442 if (PyErr_Occurred()) SWIG_fail;
49443 }
49444 {
49445 resultobj = PyList_New(0);
49446 size_t idx;
49447 for (idx = 0; idx < result->GetCount(); idx += 1) {
49448 PyObject* val = PyInt_FromLong( result->Item(idx) );
49449 PyList_Append(resultobj, val);
49450 Py_DECREF(val);
49451 }
49452 }
49453 return resultobj;
49454 fail:
49455 return NULL;
49456 }
49457
49458
49459 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49460 PyObject *resultobj = 0;
49461 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49462 wxArrayInt *result = 0 ;
49463 void *argp1 = 0 ;
49464 int res1 = 0 ;
49465 PyObject *swig_obj[1] ;
49466
49467 if (!args) SWIG_fail;
49468 swig_obj[0] = args;
49469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49470 if (!SWIG_IsOK(res1)) {
49471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49472 }
49473 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49474 {
49475 PyThreadState* __tstate = wxPyBeginAllowThreads();
49476 {
49477 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49478 result = (wxArrayInt *) &_result_ref;
49479 }
49480 wxPyEndAllowThreads(__tstate);
49481 if (PyErr_Occurred()) SWIG_fail;
49482 }
49483 {
49484 resultobj = PyList_New(0);
49485 size_t idx;
49486 for (idx = 0; idx < result->GetCount(); idx += 1) {
49487 PyObject* val = PyInt_FromLong( result->Item(idx) );
49488 PyList_Append(resultobj, val);
49489 Py_DECREF(val);
49490 }
49491 }
49492 return resultobj;
49493 fail:
49494 return NULL;
49495 }
49496
49497
49498 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49499 PyObject *obj;
49500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49501 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49502 return SWIG_Py_Void();
49503 }
49504
49505 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49506 return SWIG_Python_InitShadowInstance(args);
49507 }
49508
49509 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49510 PyObject *resultobj = 0;
49511 wxStdDialogButtonSizer *result = 0 ;
49512
49513 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49514 {
49515 PyThreadState* __tstate = wxPyBeginAllowThreads();
49516 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49517 wxPyEndAllowThreads(__tstate);
49518 if (PyErr_Occurred()) SWIG_fail;
49519 }
49520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49521 return resultobj;
49522 fail:
49523 return NULL;
49524 }
49525
49526
49527 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49528 PyObject *resultobj = 0;
49529 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49530 wxButton *arg2 = (wxButton *) 0 ;
49531 void *argp1 = 0 ;
49532 int res1 = 0 ;
49533 void *argp2 = 0 ;
49534 int res2 = 0 ;
49535 PyObject * obj0 = 0 ;
49536 PyObject * obj1 = 0 ;
49537 char * kwnames[] = {
49538 (char *) "self",(char *) "button", NULL
49539 };
49540
49541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49543 if (!SWIG_IsOK(res1)) {
49544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49545 }
49546 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49548 if (!SWIG_IsOK(res2)) {
49549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49550 }
49551 arg2 = reinterpret_cast< wxButton * >(argp2);
49552 {
49553 PyThreadState* __tstate = wxPyBeginAllowThreads();
49554 (arg1)->AddButton(arg2);
49555 wxPyEndAllowThreads(__tstate);
49556 if (PyErr_Occurred()) SWIG_fail;
49557 }
49558 resultobj = SWIG_Py_Void();
49559 return resultobj;
49560 fail:
49561 return NULL;
49562 }
49563
49564
49565 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49566 PyObject *resultobj = 0;
49567 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49568 void *argp1 = 0 ;
49569 int res1 = 0 ;
49570 PyObject *swig_obj[1] ;
49571
49572 if (!args) SWIG_fail;
49573 swig_obj[0] = args;
49574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49575 if (!SWIG_IsOK(res1)) {
49576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49577 }
49578 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49579 {
49580 PyThreadState* __tstate = wxPyBeginAllowThreads();
49581 (arg1)->Realize();
49582 wxPyEndAllowThreads(__tstate);
49583 if (PyErr_Occurred()) SWIG_fail;
49584 }
49585 resultobj = SWIG_Py_Void();
49586 return resultobj;
49587 fail:
49588 return NULL;
49589 }
49590
49591
49592 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49593 PyObject *resultobj = 0;
49594 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49595 wxButton *arg2 = (wxButton *) 0 ;
49596 void *argp1 = 0 ;
49597 int res1 = 0 ;
49598 void *argp2 = 0 ;
49599 int res2 = 0 ;
49600 PyObject * obj0 = 0 ;
49601 PyObject * obj1 = 0 ;
49602 char * kwnames[] = {
49603 (char *) "self",(char *) "button", NULL
49604 };
49605
49606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49608 if (!SWIG_IsOK(res1)) {
49609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49610 }
49611 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49613 if (!SWIG_IsOK(res2)) {
49614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49615 }
49616 arg2 = reinterpret_cast< wxButton * >(argp2);
49617 {
49618 PyThreadState* __tstate = wxPyBeginAllowThreads();
49619 (arg1)->SetAffirmativeButton(arg2);
49620 wxPyEndAllowThreads(__tstate);
49621 if (PyErr_Occurred()) SWIG_fail;
49622 }
49623 resultobj = SWIG_Py_Void();
49624 return resultobj;
49625 fail:
49626 return NULL;
49627 }
49628
49629
49630 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49631 PyObject *resultobj = 0;
49632 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49633 wxButton *arg2 = (wxButton *) 0 ;
49634 void *argp1 = 0 ;
49635 int res1 = 0 ;
49636 void *argp2 = 0 ;
49637 int res2 = 0 ;
49638 PyObject * obj0 = 0 ;
49639 PyObject * obj1 = 0 ;
49640 char * kwnames[] = {
49641 (char *) "self",(char *) "button", NULL
49642 };
49643
49644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49646 if (!SWIG_IsOK(res1)) {
49647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49648 }
49649 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49651 if (!SWIG_IsOK(res2)) {
49652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49653 }
49654 arg2 = reinterpret_cast< wxButton * >(argp2);
49655 {
49656 PyThreadState* __tstate = wxPyBeginAllowThreads();
49657 (arg1)->SetNegativeButton(arg2);
49658 wxPyEndAllowThreads(__tstate);
49659 if (PyErr_Occurred()) SWIG_fail;
49660 }
49661 resultobj = SWIG_Py_Void();
49662 return resultobj;
49663 fail:
49664 return NULL;
49665 }
49666
49667
49668 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49669 PyObject *resultobj = 0;
49670 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49671 wxButton *arg2 = (wxButton *) 0 ;
49672 void *argp1 = 0 ;
49673 int res1 = 0 ;
49674 void *argp2 = 0 ;
49675 int res2 = 0 ;
49676 PyObject * obj0 = 0 ;
49677 PyObject * obj1 = 0 ;
49678 char * kwnames[] = {
49679 (char *) "self",(char *) "button", NULL
49680 };
49681
49682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49684 if (!SWIG_IsOK(res1)) {
49685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49686 }
49687 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49688 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49689 if (!SWIG_IsOK(res2)) {
49690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49691 }
49692 arg2 = reinterpret_cast< wxButton * >(argp2);
49693 {
49694 PyThreadState* __tstate = wxPyBeginAllowThreads();
49695 (arg1)->SetCancelButton(arg2);
49696 wxPyEndAllowThreads(__tstate);
49697 if (PyErr_Occurred()) SWIG_fail;
49698 }
49699 resultobj = SWIG_Py_Void();
49700 return resultobj;
49701 fail:
49702 return NULL;
49703 }
49704
49705
49706 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49707 PyObject *resultobj = 0;
49708 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49709 wxButton *result = 0 ;
49710 void *argp1 = 0 ;
49711 int res1 = 0 ;
49712 PyObject *swig_obj[1] ;
49713
49714 if (!args) SWIG_fail;
49715 swig_obj[0] = args;
49716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49717 if (!SWIG_IsOK(res1)) {
49718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49719 }
49720 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49721 {
49722 PyThreadState* __tstate = wxPyBeginAllowThreads();
49723 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49724 wxPyEndAllowThreads(__tstate);
49725 if (PyErr_Occurred()) SWIG_fail;
49726 }
49727 {
49728 resultobj = wxPyMake_wxObject(result, (bool)0);
49729 }
49730 return resultobj;
49731 fail:
49732 return NULL;
49733 }
49734
49735
49736 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49737 PyObject *resultobj = 0;
49738 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49739 wxButton *result = 0 ;
49740 void *argp1 = 0 ;
49741 int res1 = 0 ;
49742 PyObject *swig_obj[1] ;
49743
49744 if (!args) SWIG_fail;
49745 swig_obj[0] = args;
49746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49747 if (!SWIG_IsOK(res1)) {
49748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49749 }
49750 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49751 {
49752 PyThreadState* __tstate = wxPyBeginAllowThreads();
49753 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49754 wxPyEndAllowThreads(__tstate);
49755 if (PyErr_Occurred()) SWIG_fail;
49756 }
49757 {
49758 resultobj = wxPyMake_wxObject(result, (bool)0);
49759 }
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49767 PyObject *resultobj = 0;
49768 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49769 wxButton *result = 0 ;
49770 void *argp1 = 0 ;
49771 int res1 = 0 ;
49772 PyObject *swig_obj[1] ;
49773
49774 if (!args) SWIG_fail;
49775 swig_obj[0] = args;
49776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49777 if (!SWIG_IsOK(res1)) {
49778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49779 }
49780 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49781 {
49782 PyThreadState* __tstate = wxPyBeginAllowThreads();
49783 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49784 wxPyEndAllowThreads(__tstate);
49785 if (PyErr_Occurred()) SWIG_fail;
49786 }
49787 {
49788 resultobj = wxPyMake_wxObject(result, (bool)0);
49789 }
49790 return resultobj;
49791 fail:
49792 return NULL;
49793 }
49794
49795
49796 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49797 PyObject *resultobj = 0;
49798 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49799 wxButton *result = 0 ;
49800 void *argp1 = 0 ;
49801 int res1 = 0 ;
49802 PyObject *swig_obj[1] ;
49803
49804 if (!args) SWIG_fail;
49805 swig_obj[0] = args;
49806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49807 if (!SWIG_IsOK(res1)) {
49808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49809 }
49810 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49811 {
49812 PyThreadState* __tstate = wxPyBeginAllowThreads();
49813 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49814 wxPyEndAllowThreads(__tstate);
49815 if (PyErr_Occurred()) SWIG_fail;
49816 }
49817 {
49818 resultobj = wxPyMake_wxObject(result, (bool)0);
49819 }
49820 return resultobj;
49821 fail:
49822 return NULL;
49823 }
49824
49825
49826 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49827 PyObject *resultobj = 0;
49828 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49829 wxButton *result = 0 ;
49830 void *argp1 = 0 ;
49831 int res1 = 0 ;
49832 PyObject *swig_obj[1] ;
49833
49834 if (!args) SWIG_fail;
49835 swig_obj[0] = args;
49836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49837 if (!SWIG_IsOK(res1)) {
49838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49839 }
49840 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49841 {
49842 PyThreadState* __tstate = wxPyBeginAllowThreads();
49843 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49844 wxPyEndAllowThreads(__tstate);
49845 if (PyErr_Occurred()) SWIG_fail;
49846 }
49847 {
49848 resultobj = wxPyMake_wxObject(result, (bool)0);
49849 }
49850 return resultobj;
49851 fail:
49852 return NULL;
49853 }
49854
49855
49856 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49857 PyObject *obj;
49858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49859 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49860 return SWIG_Py_Void();
49861 }
49862
49863 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49864 return SWIG_Python_InitShadowInstance(args);
49865 }
49866
49867 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49868 PyObject *resultobj = 0;
49869 int arg1 = (int) 0 ;
49870 int arg2 = (int) 0 ;
49871 wxGBPosition *result = 0 ;
49872 int val1 ;
49873 int ecode1 = 0 ;
49874 int val2 ;
49875 int ecode2 = 0 ;
49876 PyObject * obj0 = 0 ;
49877 PyObject * obj1 = 0 ;
49878 char * kwnames[] = {
49879 (char *) "row",(char *) "col", NULL
49880 };
49881
49882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49883 if (obj0) {
49884 ecode1 = SWIG_AsVal_int(obj0, &val1);
49885 if (!SWIG_IsOK(ecode1)) {
49886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49887 }
49888 arg1 = static_cast< int >(val1);
49889 }
49890 if (obj1) {
49891 ecode2 = SWIG_AsVal_int(obj1, &val2);
49892 if (!SWIG_IsOK(ecode2)) {
49893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49894 }
49895 arg2 = static_cast< int >(val2);
49896 }
49897 {
49898 PyThreadState* __tstate = wxPyBeginAllowThreads();
49899 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49900 wxPyEndAllowThreads(__tstate);
49901 if (PyErr_Occurred()) SWIG_fail;
49902 }
49903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49904 return resultobj;
49905 fail:
49906 return NULL;
49907 }
49908
49909
49910 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49911 PyObject *resultobj = 0;
49912 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49913 void *argp1 = 0 ;
49914 int res1 = 0 ;
49915 PyObject *swig_obj[1] ;
49916
49917 if (!args) SWIG_fail;
49918 swig_obj[0] = args;
49919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49920 if (!SWIG_IsOK(res1)) {
49921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49922 }
49923 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49924 {
49925 PyThreadState* __tstate = wxPyBeginAllowThreads();
49926 delete arg1;
49927
49928 wxPyEndAllowThreads(__tstate);
49929 if (PyErr_Occurred()) SWIG_fail;
49930 }
49931 resultobj = SWIG_Py_Void();
49932 return resultobj;
49933 fail:
49934 return NULL;
49935 }
49936
49937
49938 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49939 PyObject *resultobj = 0;
49940 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49941 int result;
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_wxGBPosition, 0 | 0 );
49949 if (!SWIG_IsOK(res1)) {
49950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49951 }
49952 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49953 {
49954 PyThreadState* __tstate = wxPyBeginAllowThreads();
49955 result = (int)((wxGBPosition const *)arg1)->GetRow();
49956 wxPyEndAllowThreads(__tstate);
49957 if (PyErr_Occurred()) SWIG_fail;
49958 }
49959 resultobj = SWIG_From_int(static_cast< int >(result));
49960 return resultobj;
49961 fail:
49962 return NULL;
49963 }
49964
49965
49966 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49967 PyObject *resultobj = 0;
49968 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49969 int result;
49970 void *argp1 = 0 ;
49971 int res1 = 0 ;
49972 PyObject *swig_obj[1] ;
49973
49974 if (!args) SWIG_fail;
49975 swig_obj[0] = args;
49976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49977 if (!SWIG_IsOK(res1)) {
49978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49979 }
49980 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49981 {
49982 PyThreadState* __tstate = wxPyBeginAllowThreads();
49983 result = (int)((wxGBPosition const *)arg1)->GetCol();
49984 wxPyEndAllowThreads(__tstate);
49985 if (PyErr_Occurred()) SWIG_fail;
49986 }
49987 resultobj = SWIG_From_int(static_cast< int >(result));
49988 return resultobj;
49989 fail:
49990 return NULL;
49991 }
49992
49993
49994 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49995 PyObject *resultobj = 0;
49996 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49997 int arg2 ;
49998 void *argp1 = 0 ;
49999 int res1 = 0 ;
50000 int val2 ;
50001 int ecode2 = 0 ;
50002 PyObject * obj0 = 0 ;
50003 PyObject * obj1 = 0 ;
50004 char * kwnames[] = {
50005 (char *) "self",(char *) "row", NULL
50006 };
50007
50008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50010 if (!SWIG_IsOK(res1)) {
50011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50012 }
50013 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50014 ecode2 = SWIG_AsVal_int(obj1, &val2);
50015 if (!SWIG_IsOK(ecode2)) {
50016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50017 }
50018 arg2 = static_cast< int >(val2);
50019 {
50020 PyThreadState* __tstate = wxPyBeginAllowThreads();
50021 (arg1)->SetRow(arg2);
50022 wxPyEndAllowThreads(__tstate);
50023 if (PyErr_Occurred()) SWIG_fail;
50024 }
50025 resultobj = SWIG_Py_Void();
50026 return resultobj;
50027 fail:
50028 return NULL;
50029 }
50030
50031
50032 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50033 PyObject *resultobj = 0;
50034 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50035 int arg2 ;
50036 void *argp1 = 0 ;
50037 int res1 = 0 ;
50038 int val2 ;
50039 int ecode2 = 0 ;
50040 PyObject * obj0 = 0 ;
50041 PyObject * obj1 = 0 ;
50042 char * kwnames[] = {
50043 (char *) "self",(char *) "col", NULL
50044 };
50045
50046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50048 if (!SWIG_IsOK(res1)) {
50049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50050 }
50051 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50052 ecode2 = SWIG_AsVal_int(obj1, &val2);
50053 if (!SWIG_IsOK(ecode2)) {
50054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50055 }
50056 arg2 = static_cast< int >(val2);
50057 {
50058 PyThreadState* __tstate = wxPyBeginAllowThreads();
50059 (arg1)->SetCol(arg2);
50060 wxPyEndAllowThreads(__tstate);
50061 if (PyErr_Occurred()) SWIG_fail;
50062 }
50063 resultobj = SWIG_Py_Void();
50064 return resultobj;
50065 fail:
50066 return NULL;
50067 }
50068
50069
50070 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50071 PyObject *resultobj = 0;
50072 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50073 PyObject *arg2 = (PyObject *) 0 ;
50074 bool result;
50075 void *argp1 = 0 ;
50076 int res1 = 0 ;
50077 PyObject * obj0 = 0 ;
50078 PyObject * obj1 = 0 ;
50079 char * kwnames[] = {
50080 (char *) "self",(char *) "other", NULL
50081 };
50082
50083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50085 if (!SWIG_IsOK(res1)) {
50086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50087 }
50088 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50089 arg2 = obj1;
50090 {
50091 result = (bool)wxGBPosition___eq__(arg1,arg2);
50092 if (PyErr_Occurred()) SWIG_fail;
50093 }
50094 {
50095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50096 }
50097 return resultobj;
50098 fail:
50099 return NULL;
50100 }
50101
50102
50103 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50104 PyObject *resultobj = 0;
50105 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50106 PyObject *arg2 = (PyObject *) 0 ;
50107 bool result;
50108 void *argp1 = 0 ;
50109 int res1 = 0 ;
50110 PyObject * obj0 = 0 ;
50111 PyObject * obj1 = 0 ;
50112 char * kwnames[] = {
50113 (char *) "self",(char *) "other", NULL
50114 };
50115
50116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50118 if (!SWIG_IsOK(res1)) {
50119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50120 }
50121 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50122 arg2 = obj1;
50123 {
50124 result = (bool)wxGBPosition___ne__(arg1,arg2);
50125 if (PyErr_Occurred()) SWIG_fail;
50126 }
50127 {
50128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50129 }
50130 return resultobj;
50131 fail:
50132 return NULL;
50133 }
50134
50135
50136 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50137 PyObject *resultobj = 0;
50138 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50139 int arg2 = (int) 0 ;
50140 int arg3 = (int) 0 ;
50141 void *argp1 = 0 ;
50142 int res1 = 0 ;
50143 int val2 ;
50144 int ecode2 = 0 ;
50145 int val3 ;
50146 int ecode3 = 0 ;
50147 PyObject * obj0 = 0 ;
50148 PyObject * obj1 = 0 ;
50149 PyObject * obj2 = 0 ;
50150 char * kwnames[] = {
50151 (char *) "self",(char *) "row",(char *) "col", NULL
50152 };
50153
50154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50156 if (!SWIG_IsOK(res1)) {
50157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50158 }
50159 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50160 if (obj1) {
50161 ecode2 = SWIG_AsVal_int(obj1, &val2);
50162 if (!SWIG_IsOK(ecode2)) {
50163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50164 }
50165 arg2 = static_cast< int >(val2);
50166 }
50167 if (obj2) {
50168 ecode3 = SWIG_AsVal_int(obj2, &val3);
50169 if (!SWIG_IsOK(ecode3)) {
50170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50171 }
50172 arg3 = static_cast< int >(val3);
50173 }
50174 {
50175 PyThreadState* __tstate = wxPyBeginAllowThreads();
50176 wxGBPosition_Set(arg1,arg2,arg3);
50177 wxPyEndAllowThreads(__tstate);
50178 if (PyErr_Occurred()) SWIG_fail;
50179 }
50180 resultobj = SWIG_Py_Void();
50181 return resultobj;
50182 fail:
50183 return NULL;
50184 }
50185
50186
50187 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50188 PyObject *resultobj = 0;
50189 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50190 PyObject *result = 0 ;
50191 void *argp1 = 0 ;
50192 int res1 = 0 ;
50193 PyObject *swig_obj[1] ;
50194
50195 if (!args) SWIG_fail;
50196 swig_obj[0] = args;
50197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50198 if (!SWIG_IsOK(res1)) {
50199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50200 }
50201 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50202 {
50203 PyThreadState* __tstate = wxPyBeginAllowThreads();
50204 result = (PyObject *)wxGBPosition_Get(arg1);
50205 wxPyEndAllowThreads(__tstate);
50206 if (PyErr_Occurred()) SWIG_fail;
50207 }
50208 resultobj = result;
50209 return resultobj;
50210 fail:
50211 return NULL;
50212 }
50213
50214
50215 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50216 PyObject *obj;
50217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50218 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50219 return SWIG_Py_Void();
50220 }
50221
50222 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50223 return SWIG_Python_InitShadowInstance(args);
50224 }
50225
50226 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50227 PyObject *resultobj = 0;
50228 int arg1 = (int) 1 ;
50229 int arg2 = (int) 1 ;
50230 wxGBSpan *result = 0 ;
50231 int val1 ;
50232 int ecode1 = 0 ;
50233 int val2 ;
50234 int ecode2 = 0 ;
50235 PyObject * obj0 = 0 ;
50236 PyObject * obj1 = 0 ;
50237 char * kwnames[] = {
50238 (char *) "rowspan",(char *) "colspan", NULL
50239 };
50240
50241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50242 if (obj0) {
50243 ecode1 = SWIG_AsVal_int(obj0, &val1);
50244 if (!SWIG_IsOK(ecode1)) {
50245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50246 }
50247 arg1 = static_cast< int >(val1);
50248 }
50249 if (obj1) {
50250 ecode2 = SWIG_AsVal_int(obj1, &val2);
50251 if (!SWIG_IsOK(ecode2)) {
50252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50253 }
50254 arg2 = static_cast< int >(val2);
50255 }
50256 {
50257 PyThreadState* __tstate = wxPyBeginAllowThreads();
50258 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50259 wxPyEndAllowThreads(__tstate);
50260 if (PyErr_Occurred()) SWIG_fail;
50261 }
50262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50263 return resultobj;
50264 fail:
50265 return NULL;
50266 }
50267
50268
50269 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50270 PyObject *resultobj = 0;
50271 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50272 void *argp1 = 0 ;
50273 int res1 = 0 ;
50274 PyObject *swig_obj[1] ;
50275
50276 if (!args) SWIG_fail;
50277 swig_obj[0] = args;
50278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50279 if (!SWIG_IsOK(res1)) {
50280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50281 }
50282 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50283 {
50284 PyThreadState* __tstate = wxPyBeginAllowThreads();
50285 delete arg1;
50286
50287 wxPyEndAllowThreads(__tstate);
50288 if (PyErr_Occurred()) SWIG_fail;
50289 }
50290 resultobj = SWIG_Py_Void();
50291 return resultobj;
50292 fail:
50293 return NULL;
50294 }
50295
50296
50297 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50298 PyObject *resultobj = 0;
50299 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50300 int result;
50301 void *argp1 = 0 ;
50302 int res1 = 0 ;
50303 PyObject *swig_obj[1] ;
50304
50305 if (!args) SWIG_fail;
50306 swig_obj[0] = args;
50307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50308 if (!SWIG_IsOK(res1)) {
50309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50310 }
50311 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50312 {
50313 PyThreadState* __tstate = wxPyBeginAllowThreads();
50314 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50315 wxPyEndAllowThreads(__tstate);
50316 if (PyErr_Occurred()) SWIG_fail;
50317 }
50318 resultobj = SWIG_From_int(static_cast< int >(result));
50319 return resultobj;
50320 fail:
50321 return NULL;
50322 }
50323
50324
50325 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50326 PyObject *resultobj = 0;
50327 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50328 int result;
50329 void *argp1 = 0 ;
50330 int res1 = 0 ;
50331 PyObject *swig_obj[1] ;
50332
50333 if (!args) SWIG_fail;
50334 swig_obj[0] = args;
50335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50336 if (!SWIG_IsOK(res1)) {
50337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50338 }
50339 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50340 {
50341 PyThreadState* __tstate = wxPyBeginAllowThreads();
50342 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50343 wxPyEndAllowThreads(__tstate);
50344 if (PyErr_Occurred()) SWIG_fail;
50345 }
50346 resultobj = SWIG_From_int(static_cast< int >(result));
50347 return resultobj;
50348 fail:
50349 return NULL;
50350 }
50351
50352
50353 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50354 PyObject *resultobj = 0;
50355 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50356 int arg2 ;
50357 void *argp1 = 0 ;
50358 int res1 = 0 ;
50359 int val2 ;
50360 int ecode2 = 0 ;
50361 PyObject * obj0 = 0 ;
50362 PyObject * obj1 = 0 ;
50363 char * kwnames[] = {
50364 (char *) "self",(char *) "rowspan", NULL
50365 };
50366
50367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50369 if (!SWIG_IsOK(res1)) {
50370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50371 }
50372 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50373 ecode2 = SWIG_AsVal_int(obj1, &val2);
50374 if (!SWIG_IsOK(ecode2)) {
50375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50376 }
50377 arg2 = static_cast< int >(val2);
50378 {
50379 PyThreadState* __tstate = wxPyBeginAllowThreads();
50380 (arg1)->SetRowspan(arg2);
50381 wxPyEndAllowThreads(__tstate);
50382 if (PyErr_Occurred()) SWIG_fail;
50383 }
50384 resultobj = SWIG_Py_Void();
50385 return resultobj;
50386 fail:
50387 return NULL;
50388 }
50389
50390
50391 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50392 PyObject *resultobj = 0;
50393 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50394 int arg2 ;
50395 void *argp1 = 0 ;
50396 int res1 = 0 ;
50397 int val2 ;
50398 int ecode2 = 0 ;
50399 PyObject * obj0 = 0 ;
50400 PyObject * obj1 = 0 ;
50401 char * kwnames[] = {
50402 (char *) "self",(char *) "colspan", NULL
50403 };
50404
50405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50407 if (!SWIG_IsOK(res1)) {
50408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50409 }
50410 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50411 ecode2 = SWIG_AsVal_int(obj1, &val2);
50412 if (!SWIG_IsOK(ecode2)) {
50413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50414 }
50415 arg2 = static_cast< int >(val2);
50416 {
50417 PyThreadState* __tstate = wxPyBeginAllowThreads();
50418 (arg1)->SetColspan(arg2);
50419 wxPyEndAllowThreads(__tstate);
50420 if (PyErr_Occurred()) SWIG_fail;
50421 }
50422 resultobj = SWIG_Py_Void();
50423 return resultobj;
50424 fail:
50425 return NULL;
50426 }
50427
50428
50429 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50430 PyObject *resultobj = 0;
50431 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50432 PyObject *arg2 = (PyObject *) 0 ;
50433 bool result;
50434 void *argp1 = 0 ;
50435 int res1 = 0 ;
50436 PyObject * obj0 = 0 ;
50437 PyObject * obj1 = 0 ;
50438 char * kwnames[] = {
50439 (char *) "self",(char *) "other", NULL
50440 };
50441
50442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50444 if (!SWIG_IsOK(res1)) {
50445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50446 }
50447 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50448 arg2 = obj1;
50449 {
50450 result = (bool)wxGBSpan___eq__(arg1,arg2);
50451 if (PyErr_Occurred()) SWIG_fail;
50452 }
50453 {
50454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50455 }
50456 return resultobj;
50457 fail:
50458 return NULL;
50459 }
50460
50461
50462 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50463 PyObject *resultobj = 0;
50464 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50465 PyObject *arg2 = (PyObject *) 0 ;
50466 bool result;
50467 void *argp1 = 0 ;
50468 int res1 = 0 ;
50469 PyObject * obj0 = 0 ;
50470 PyObject * obj1 = 0 ;
50471 char * kwnames[] = {
50472 (char *) "self",(char *) "other", NULL
50473 };
50474
50475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50477 if (!SWIG_IsOK(res1)) {
50478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50479 }
50480 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50481 arg2 = obj1;
50482 {
50483 result = (bool)wxGBSpan___ne__(arg1,arg2);
50484 if (PyErr_Occurred()) SWIG_fail;
50485 }
50486 {
50487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50488 }
50489 return resultobj;
50490 fail:
50491 return NULL;
50492 }
50493
50494
50495 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50496 PyObject *resultobj = 0;
50497 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50498 int arg2 = (int) 1 ;
50499 int arg3 = (int) 1 ;
50500 void *argp1 = 0 ;
50501 int res1 = 0 ;
50502 int val2 ;
50503 int ecode2 = 0 ;
50504 int val3 ;
50505 int ecode3 = 0 ;
50506 PyObject * obj0 = 0 ;
50507 PyObject * obj1 = 0 ;
50508 PyObject * obj2 = 0 ;
50509 char * kwnames[] = {
50510 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50511 };
50512
50513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50515 if (!SWIG_IsOK(res1)) {
50516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50517 }
50518 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50519 if (obj1) {
50520 ecode2 = SWIG_AsVal_int(obj1, &val2);
50521 if (!SWIG_IsOK(ecode2)) {
50522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50523 }
50524 arg2 = static_cast< int >(val2);
50525 }
50526 if (obj2) {
50527 ecode3 = SWIG_AsVal_int(obj2, &val3);
50528 if (!SWIG_IsOK(ecode3)) {
50529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50530 }
50531 arg3 = static_cast< int >(val3);
50532 }
50533 {
50534 PyThreadState* __tstate = wxPyBeginAllowThreads();
50535 wxGBSpan_Set(arg1,arg2,arg3);
50536 wxPyEndAllowThreads(__tstate);
50537 if (PyErr_Occurred()) SWIG_fail;
50538 }
50539 resultobj = SWIG_Py_Void();
50540 return resultobj;
50541 fail:
50542 return NULL;
50543 }
50544
50545
50546 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50547 PyObject *resultobj = 0;
50548 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50549 PyObject *result = 0 ;
50550 void *argp1 = 0 ;
50551 int res1 = 0 ;
50552 PyObject *swig_obj[1] ;
50553
50554 if (!args) SWIG_fail;
50555 swig_obj[0] = args;
50556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50557 if (!SWIG_IsOK(res1)) {
50558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50559 }
50560 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50561 {
50562 PyThreadState* __tstate = wxPyBeginAllowThreads();
50563 result = (PyObject *)wxGBSpan_Get(arg1);
50564 wxPyEndAllowThreads(__tstate);
50565 if (PyErr_Occurred()) SWIG_fail;
50566 }
50567 resultobj = result;
50568 return resultobj;
50569 fail:
50570 return NULL;
50571 }
50572
50573
50574 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50575 PyObject *obj;
50576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50577 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50578 return SWIG_Py_Void();
50579 }
50580
50581 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50582 return SWIG_Python_InitShadowInstance(args);
50583 }
50584
50585 SWIGINTERN int DefaultSpan_set(PyObject *) {
50586 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50587 return 1;
50588 }
50589
50590
50591 SWIGINTERN PyObject *DefaultSpan_get(void) {
50592 PyObject *pyobj = 0;
50593
50594 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50595 return pyobj;
50596 }
50597
50598
50599 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50600 PyObject *resultobj = 0;
50601 wxGBSizerItem *result = 0 ;
50602
50603 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50604 {
50605 PyThreadState* __tstate = wxPyBeginAllowThreads();
50606 result = (wxGBSizerItem *)new wxGBSizerItem();
50607 wxPyEndAllowThreads(__tstate);
50608 if (PyErr_Occurred()) SWIG_fail;
50609 }
50610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50611 return resultobj;
50612 fail:
50613 return NULL;
50614 }
50615
50616
50617 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50618 PyObject *resultobj = 0;
50619 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50620 void *argp1 = 0 ;
50621 int res1 = 0 ;
50622 PyObject *swig_obj[1] ;
50623
50624 if (!args) SWIG_fail;
50625 swig_obj[0] = args;
50626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50627 if (!SWIG_IsOK(res1)) {
50628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50629 }
50630 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50631 {
50632 PyThreadState* __tstate = wxPyBeginAllowThreads();
50633 delete arg1;
50634
50635 wxPyEndAllowThreads(__tstate);
50636 if (PyErr_Occurred()) SWIG_fail;
50637 }
50638 resultobj = SWIG_Py_Void();
50639 return resultobj;
50640 fail:
50641 return NULL;
50642 }
50643
50644
50645 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50646 PyObject *resultobj = 0;
50647 wxWindow *arg1 = (wxWindow *) 0 ;
50648 wxGBPosition *arg2 = 0 ;
50649 wxGBSpan *arg3 = 0 ;
50650 int arg4 ;
50651 int arg5 ;
50652 PyObject *arg6 = (PyObject *) NULL ;
50653 wxGBSizerItem *result = 0 ;
50654 void *argp1 = 0 ;
50655 int res1 = 0 ;
50656 wxGBPosition temp2 ;
50657 wxGBSpan temp3 ;
50658 int val4 ;
50659 int ecode4 = 0 ;
50660 int val5 ;
50661 int ecode5 = 0 ;
50662 PyObject * obj0 = 0 ;
50663 PyObject * obj1 = 0 ;
50664 PyObject * obj2 = 0 ;
50665 PyObject * obj3 = 0 ;
50666 PyObject * obj4 = 0 ;
50667 PyObject * obj5 = 0 ;
50668 char * kwnames[] = {
50669 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50670 };
50671
50672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50674 if (!SWIG_IsOK(res1)) {
50675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50676 }
50677 arg1 = reinterpret_cast< wxWindow * >(argp1);
50678 {
50679 arg2 = &temp2;
50680 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50681 }
50682 {
50683 arg3 = &temp3;
50684 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50685 }
50686 ecode4 = SWIG_AsVal_int(obj3, &val4);
50687 if (!SWIG_IsOK(ecode4)) {
50688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50689 }
50690 arg4 = static_cast< int >(val4);
50691 ecode5 = SWIG_AsVal_int(obj4, &val5);
50692 if (!SWIG_IsOK(ecode5)) {
50693 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50694 }
50695 arg5 = static_cast< int >(val5);
50696 if (obj5) {
50697 arg6 = obj5;
50698 }
50699 {
50700 PyThreadState* __tstate = wxPyBeginAllowThreads();
50701 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50702 wxPyEndAllowThreads(__tstate);
50703 if (PyErr_Occurred()) SWIG_fail;
50704 }
50705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50706 return resultobj;
50707 fail:
50708 return NULL;
50709 }
50710
50711
50712 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50713 PyObject *resultobj = 0;
50714 wxSizer *arg1 = (wxSizer *) 0 ;
50715 wxGBPosition *arg2 = 0 ;
50716 wxGBSpan *arg3 = 0 ;
50717 int arg4 ;
50718 int arg5 ;
50719 PyObject *arg6 = (PyObject *) NULL ;
50720 wxGBSizerItem *result = 0 ;
50721 int res1 = 0 ;
50722 wxGBPosition temp2 ;
50723 wxGBSpan temp3 ;
50724 int val4 ;
50725 int ecode4 = 0 ;
50726 int val5 ;
50727 int ecode5 = 0 ;
50728 PyObject * obj0 = 0 ;
50729 PyObject * obj1 = 0 ;
50730 PyObject * obj2 = 0 ;
50731 PyObject * obj3 = 0 ;
50732 PyObject * obj4 = 0 ;
50733 PyObject * obj5 = 0 ;
50734 char * kwnames[] = {
50735 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50736 };
50737
50738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50739 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50740 if (!SWIG_IsOK(res1)) {
50741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50742 }
50743 {
50744 arg2 = &temp2;
50745 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50746 }
50747 {
50748 arg3 = &temp3;
50749 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50750 }
50751 ecode4 = SWIG_AsVal_int(obj3, &val4);
50752 if (!SWIG_IsOK(ecode4)) {
50753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50754 }
50755 arg4 = static_cast< int >(val4);
50756 ecode5 = SWIG_AsVal_int(obj4, &val5);
50757 if (!SWIG_IsOK(ecode5)) {
50758 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50759 }
50760 arg5 = static_cast< int >(val5);
50761 if (obj5) {
50762 arg6 = obj5;
50763 }
50764 {
50765 PyThreadState* __tstate = wxPyBeginAllowThreads();
50766 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50767 wxPyEndAllowThreads(__tstate);
50768 if (PyErr_Occurred()) SWIG_fail;
50769 }
50770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50771 return resultobj;
50772 fail:
50773 return NULL;
50774 }
50775
50776
50777 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50778 PyObject *resultobj = 0;
50779 int arg1 ;
50780 int arg2 ;
50781 wxGBPosition *arg3 = 0 ;
50782 wxGBSpan *arg4 = 0 ;
50783 int arg5 ;
50784 int arg6 ;
50785 PyObject *arg7 = (PyObject *) NULL ;
50786 wxGBSizerItem *result = 0 ;
50787 int val1 ;
50788 int ecode1 = 0 ;
50789 int val2 ;
50790 int ecode2 = 0 ;
50791 wxGBPosition temp3 ;
50792 wxGBSpan temp4 ;
50793 int val5 ;
50794 int ecode5 = 0 ;
50795 int val6 ;
50796 int ecode6 = 0 ;
50797 PyObject * obj0 = 0 ;
50798 PyObject * obj1 = 0 ;
50799 PyObject * obj2 = 0 ;
50800 PyObject * obj3 = 0 ;
50801 PyObject * obj4 = 0 ;
50802 PyObject * obj5 = 0 ;
50803 PyObject * obj6 = 0 ;
50804 char * kwnames[] = {
50805 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50806 };
50807
50808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50809 ecode1 = SWIG_AsVal_int(obj0, &val1);
50810 if (!SWIG_IsOK(ecode1)) {
50811 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50812 }
50813 arg1 = static_cast< int >(val1);
50814 ecode2 = SWIG_AsVal_int(obj1, &val2);
50815 if (!SWIG_IsOK(ecode2)) {
50816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50817 }
50818 arg2 = static_cast< int >(val2);
50819 {
50820 arg3 = &temp3;
50821 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50822 }
50823 {
50824 arg4 = &temp4;
50825 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50826 }
50827 ecode5 = SWIG_AsVal_int(obj4, &val5);
50828 if (!SWIG_IsOK(ecode5)) {
50829 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50830 }
50831 arg5 = static_cast< int >(val5);
50832 ecode6 = SWIG_AsVal_int(obj5, &val6);
50833 if (!SWIG_IsOK(ecode6)) {
50834 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50835 }
50836 arg6 = static_cast< int >(val6);
50837 if (obj6) {
50838 arg7 = obj6;
50839 }
50840 {
50841 PyThreadState* __tstate = wxPyBeginAllowThreads();
50842 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50843 wxPyEndAllowThreads(__tstate);
50844 if (PyErr_Occurred()) SWIG_fail;
50845 }
50846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50847 return resultobj;
50848 fail:
50849 return NULL;
50850 }
50851
50852
50853 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50854 PyObject *resultobj = 0;
50855 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50856 wxGBPosition result;
50857 void *argp1 = 0 ;
50858 int res1 = 0 ;
50859 PyObject *swig_obj[1] ;
50860
50861 if (!args) SWIG_fail;
50862 swig_obj[0] = args;
50863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50864 if (!SWIG_IsOK(res1)) {
50865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50866 }
50867 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50868 {
50869 PyThreadState* __tstate = wxPyBeginAllowThreads();
50870 result = ((wxGBSizerItem const *)arg1)->GetPos();
50871 wxPyEndAllowThreads(__tstate);
50872 if (PyErr_Occurred()) SWIG_fail;
50873 }
50874 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50875 return resultobj;
50876 fail:
50877 return NULL;
50878 }
50879
50880
50881 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50882 PyObject *resultobj = 0;
50883 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50884 wxGBSpan result;
50885 void *argp1 = 0 ;
50886 int res1 = 0 ;
50887 PyObject *swig_obj[1] ;
50888
50889 if (!args) SWIG_fail;
50890 swig_obj[0] = args;
50891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50892 if (!SWIG_IsOK(res1)) {
50893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50894 }
50895 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50896 {
50897 PyThreadState* __tstate = wxPyBeginAllowThreads();
50898 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50899 wxPyEndAllowThreads(__tstate);
50900 if (PyErr_Occurred()) SWIG_fail;
50901 }
50902 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50903 return resultobj;
50904 fail:
50905 return NULL;
50906 }
50907
50908
50909 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50910 PyObject *resultobj = 0;
50911 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50912 wxGBPosition *arg2 = 0 ;
50913 bool result;
50914 void *argp1 = 0 ;
50915 int res1 = 0 ;
50916 wxGBPosition temp2 ;
50917 PyObject * obj0 = 0 ;
50918 PyObject * obj1 = 0 ;
50919 char * kwnames[] = {
50920 (char *) "self",(char *) "pos", NULL
50921 };
50922
50923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50925 if (!SWIG_IsOK(res1)) {
50926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50927 }
50928 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50929 {
50930 arg2 = &temp2;
50931 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50932 }
50933 {
50934 PyThreadState* __tstate = wxPyBeginAllowThreads();
50935 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50936 wxPyEndAllowThreads(__tstate);
50937 if (PyErr_Occurred()) SWIG_fail;
50938 }
50939 {
50940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50941 }
50942 return resultobj;
50943 fail:
50944 return NULL;
50945 }
50946
50947
50948 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50949 PyObject *resultobj = 0;
50950 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50951 wxGBSpan *arg2 = 0 ;
50952 bool result;
50953 void *argp1 = 0 ;
50954 int res1 = 0 ;
50955 wxGBSpan temp2 ;
50956 PyObject * obj0 = 0 ;
50957 PyObject * obj1 = 0 ;
50958 char * kwnames[] = {
50959 (char *) "self",(char *) "span", NULL
50960 };
50961
50962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50964 if (!SWIG_IsOK(res1)) {
50965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50966 }
50967 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50968 {
50969 arg2 = &temp2;
50970 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50971 }
50972 {
50973 PyThreadState* __tstate = wxPyBeginAllowThreads();
50974 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50975 wxPyEndAllowThreads(__tstate);
50976 if (PyErr_Occurred()) SWIG_fail;
50977 }
50978 {
50979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50980 }
50981 return resultobj;
50982 fail:
50983 return NULL;
50984 }
50985
50986
50987 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50988 PyObject *resultobj = 0;
50989 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50990 wxGBSizerItem *arg2 = 0 ;
50991 bool result;
50992 void *argp1 = 0 ;
50993 int res1 = 0 ;
50994 void *argp2 = 0 ;
50995 int res2 = 0 ;
50996 PyObject * obj0 = 0 ;
50997 PyObject * obj1 = 0 ;
50998 char * kwnames[] = {
50999 (char *) "self",(char *) "other", NULL
51000 };
51001
51002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51004 if (!SWIG_IsOK(res1)) {
51005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51006 }
51007 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51008 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51009 if (!SWIG_IsOK(res2)) {
51010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51011 }
51012 if (!argp2) {
51013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51014 }
51015 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51016 {
51017 PyThreadState* __tstate = wxPyBeginAllowThreads();
51018 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51019 wxPyEndAllowThreads(__tstate);
51020 if (PyErr_Occurred()) SWIG_fail;
51021 }
51022 {
51023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51024 }
51025 return resultobj;
51026 fail:
51027 return NULL;
51028 }
51029
51030
51031 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51032 PyObject *resultobj = 0;
51033 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51034 wxGBPosition *arg2 = 0 ;
51035 wxGBSpan *arg3 = 0 ;
51036 bool result;
51037 void *argp1 = 0 ;
51038 int res1 = 0 ;
51039 wxGBPosition temp2 ;
51040 wxGBSpan temp3 ;
51041 PyObject * obj0 = 0 ;
51042 PyObject * obj1 = 0 ;
51043 PyObject * obj2 = 0 ;
51044 char * kwnames[] = {
51045 (char *) "self",(char *) "pos",(char *) "span", NULL
51046 };
51047
51048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51050 if (!SWIG_IsOK(res1)) {
51051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51052 }
51053 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51054 {
51055 arg2 = &temp2;
51056 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51057 }
51058 {
51059 arg3 = &temp3;
51060 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51061 }
51062 {
51063 PyThreadState* __tstate = wxPyBeginAllowThreads();
51064 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51065 wxPyEndAllowThreads(__tstate);
51066 if (PyErr_Occurred()) SWIG_fail;
51067 }
51068 {
51069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51070 }
51071 return resultobj;
51072 fail:
51073 return NULL;
51074 }
51075
51076
51077 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51078 PyObject *resultobj = 0;
51079 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51080 wxGBPosition result;
51081 void *argp1 = 0 ;
51082 int res1 = 0 ;
51083 PyObject *swig_obj[1] ;
51084
51085 if (!args) SWIG_fail;
51086 swig_obj[0] = args;
51087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51088 if (!SWIG_IsOK(res1)) {
51089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51090 }
51091 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51092 {
51093 PyThreadState* __tstate = wxPyBeginAllowThreads();
51094 result = wxGBSizerItem_GetEndPos(arg1);
51095 wxPyEndAllowThreads(__tstate);
51096 if (PyErr_Occurred()) SWIG_fail;
51097 }
51098 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51099 return resultobj;
51100 fail:
51101 return NULL;
51102 }
51103
51104
51105 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51106 PyObject *resultobj = 0;
51107 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51108 wxGridBagSizer *result = 0 ;
51109 void *argp1 = 0 ;
51110 int res1 = 0 ;
51111 PyObject *swig_obj[1] ;
51112
51113 if (!args) SWIG_fail;
51114 swig_obj[0] = args;
51115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51116 if (!SWIG_IsOK(res1)) {
51117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51118 }
51119 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51120 {
51121 PyThreadState* __tstate = wxPyBeginAllowThreads();
51122 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51123 wxPyEndAllowThreads(__tstate);
51124 if (PyErr_Occurred()) SWIG_fail;
51125 }
51126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51127 return resultobj;
51128 fail:
51129 return NULL;
51130 }
51131
51132
51133 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51134 PyObject *resultobj = 0;
51135 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51136 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51137 void *argp1 = 0 ;
51138 int res1 = 0 ;
51139 void *argp2 = 0 ;
51140 int res2 = 0 ;
51141 PyObject * obj0 = 0 ;
51142 PyObject * obj1 = 0 ;
51143 char * kwnames[] = {
51144 (char *) "self",(char *) "sizer", NULL
51145 };
51146
51147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51149 if (!SWIG_IsOK(res1)) {
51150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51151 }
51152 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51154 if (!SWIG_IsOK(res2)) {
51155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51156 }
51157 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51158 {
51159 PyThreadState* __tstate = wxPyBeginAllowThreads();
51160 (arg1)->SetGBSizer(arg2);
51161 wxPyEndAllowThreads(__tstate);
51162 if (PyErr_Occurred()) SWIG_fail;
51163 }
51164 resultobj = SWIG_Py_Void();
51165 return resultobj;
51166 fail:
51167 return NULL;
51168 }
51169
51170
51171 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51172 PyObject *obj;
51173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51174 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51175 return SWIG_Py_Void();
51176 }
51177
51178 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51179 return SWIG_Python_InitShadowInstance(args);
51180 }
51181
51182 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51183 PyObject *resultobj = 0;
51184 int arg1 = (int) 0 ;
51185 int arg2 = (int) 0 ;
51186 wxGridBagSizer *result = 0 ;
51187 int val1 ;
51188 int ecode1 = 0 ;
51189 int val2 ;
51190 int ecode2 = 0 ;
51191 PyObject * obj0 = 0 ;
51192 PyObject * obj1 = 0 ;
51193 char * kwnames[] = {
51194 (char *) "vgap",(char *) "hgap", NULL
51195 };
51196
51197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51198 if (obj0) {
51199 ecode1 = SWIG_AsVal_int(obj0, &val1);
51200 if (!SWIG_IsOK(ecode1)) {
51201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51202 }
51203 arg1 = static_cast< int >(val1);
51204 }
51205 if (obj1) {
51206 ecode2 = SWIG_AsVal_int(obj1, &val2);
51207 if (!SWIG_IsOK(ecode2)) {
51208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51209 }
51210 arg2 = static_cast< int >(val2);
51211 }
51212 {
51213 PyThreadState* __tstate = wxPyBeginAllowThreads();
51214 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51215 wxPyEndAllowThreads(__tstate);
51216 if (PyErr_Occurred()) SWIG_fail;
51217 }
51218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51219 return resultobj;
51220 fail:
51221 return NULL;
51222 }
51223
51224
51225 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51226 PyObject *resultobj = 0;
51227 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51228 PyObject *arg2 = (PyObject *) 0 ;
51229 wxGBPosition *arg3 = 0 ;
51230 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51231 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51232 int arg5 = (int) 0 ;
51233 int arg6 = (int) 0 ;
51234 PyObject *arg7 = (PyObject *) NULL ;
51235 wxGBSizerItem *result = 0 ;
51236 void *argp1 = 0 ;
51237 int res1 = 0 ;
51238 wxGBPosition temp3 ;
51239 wxGBSpan temp4 ;
51240 int val5 ;
51241 int ecode5 = 0 ;
51242 int val6 ;
51243 int ecode6 = 0 ;
51244 PyObject * obj0 = 0 ;
51245 PyObject * obj1 = 0 ;
51246 PyObject * obj2 = 0 ;
51247 PyObject * obj3 = 0 ;
51248 PyObject * obj4 = 0 ;
51249 PyObject * obj5 = 0 ;
51250 PyObject * obj6 = 0 ;
51251 char * kwnames[] = {
51252 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51253 };
51254
51255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51257 if (!SWIG_IsOK(res1)) {
51258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51259 }
51260 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51261 arg2 = obj1;
51262 {
51263 arg3 = &temp3;
51264 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51265 }
51266 if (obj3) {
51267 {
51268 arg4 = &temp4;
51269 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51270 }
51271 }
51272 if (obj4) {
51273 ecode5 = SWIG_AsVal_int(obj4, &val5);
51274 if (!SWIG_IsOK(ecode5)) {
51275 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51276 }
51277 arg5 = static_cast< int >(val5);
51278 }
51279 if (obj5) {
51280 ecode6 = SWIG_AsVal_int(obj5, &val6);
51281 if (!SWIG_IsOK(ecode6)) {
51282 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51283 }
51284 arg6 = static_cast< int >(val6);
51285 }
51286 if (obj6) {
51287 arg7 = obj6;
51288 }
51289 {
51290 PyThreadState* __tstate = wxPyBeginAllowThreads();
51291 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51292 wxPyEndAllowThreads(__tstate);
51293 if (PyErr_Occurred()) SWIG_fail;
51294 }
51295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51296 return resultobj;
51297 fail:
51298 return NULL;
51299 }
51300
51301
51302 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51303 PyObject *resultobj = 0;
51304 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51305 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51306 wxGBSizerItem *result = 0 ;
51307 void *argp1 = 0 ;
51308 int res1 = 0 ;
51309 int res2 = 0 ;
51310 PyObject * obj0 = 0 ;
51311 PyObject * obj1 = 0 ;
51312 char * kwnames[] = {
51313 (char *) "self",(char *) "item", NULL
51314 };
51315
51316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51318 if (!SWIG_IsOK(res1)) {
51319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51320 }
51321 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51322 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51323 if (!SWIG_IsOK(res2)) {
51324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51325 }
51326 {
51327 PyThreadState* __tstate = wxPyBeginAllowThreads();
51328 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51329 wxPyEndAllowThreads(__tstate);
51330 if (PyErr_Occurred()) SWIG_fail;
51331 }
51332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51333 return resultobj;
51334 fail:
51335 return NULL;
51336 }
51337
51338
51339 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51340 PyObject *resultobj = 0;
51341 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51342 int arg2 ;
51343 int arg3 ;
51344 wxSize result;
51345 void *argp1 = 0 ;
51346 int res1 = 0 ;
51347 int val2 ;
51348 int ecode2 = 0 ;
51349 int val3 ;
51350 int ecode3 = 0 ;
51351 PyObject * obj0 = 0 ;
51352 PyObject * obj1 = 0 ;
51353 PyObject * obj2 = 0 ;
51354 char * kwnames[] = {
51355 (char *) "self",(char *) "row",(char *) "col", NULL
51356 };
51357
51358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51360 if (!SWIG_IsOK(res1)) {
51361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51362 }
51363 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51364 ecode2 = SWIG_AsVal_int(obj1, &val2);
51365 if (!SWIG_IsOK(ecode2)) {
51366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51367 }
51368 arg2 = static_cast< int >(val2);
51369 ecode3 = SWIG_AsVal_int(obj2, &val3);
51370 if (!SWIG_IsOK(ecode3)) {
51371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51372 }
51373 arg3 = static_cast< int >(val3);
51374 {
51375 PyThreadState* __tstate = wxPyBeginAllowThreads();
51376 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51377 wxPyEndAllowThreads(__tstate);
51378 if (PyErr_Occurred()) SWIG_fail;
51379 }
51380 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51381 return resultobj;
51382 fail:
51383 return NULL;
51384 }
51385
51386
51387 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51388 PyObject *resultobj = 0;
51389 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51390 wxSize result;
51391 void *argp1 = 0 ;
51392 int res1 = 0 ;
51393 PyObject *swig_obj[1] ;
51394
51395 if (!args) SWIG_fail;
51396 swig_obj[0] = args;
51397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51398 if (!SWIG_IsOK(res1)) {
51399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51400 }
51401 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51402 {
51403 PyThreadState* __tstate = wxPyBeginAllowThreads();
51404 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51405 wxPyEndAllowThreads(__tstate);
51406 if (PyErr_Occurred()) SWIG_fail;
51407 }
51408 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51409 return resultobj;
51410 fail:
51411 return NULL;
51412 }
51413
51414
51415 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51416 PyObject *resultobj = 0;
51417 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51418 wxSize *arg2 = 0 ;
51419 void *argp1 = 0 ;
51420 int res1 = 0 ;
51421 wxSize temp2 ;
51422 PyObject * obj0 = 0 ;
51423 PyObject * obj1 = 0 ;
51424 char * kwnames[] = {
51425 (char *) "self",(char *) "sz", NULL
51426 };
51427
51428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51430 if (!SWIG_IsOK(res1)) {
51431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51432 }
51433 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51434 {
51435 arg2 = &temp2;
51436 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51437 }
51438 {
51439 PyThreadState* __tstate = wxPyBeginAllowThreads();
51440 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51441 wxPyEndAllowThreads(__tstate);
51442 if (PyErr_Occurred()) SWIG_fail;
51443 }
51444 resultobj = SWIG_Py_Void();
51445 return resultobj;
51446 fail:
51447 return NULL;
51448 }
51449
51450
51451 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51452 PyObject *resultobj = 0;
51453 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51454 wxWindow *arg2 = (wxWindow *) 0 ;
51455 wxGBPosition result;
51456 void *argp1 = 0 ;
51457 int res1 = 0 ;
51458 void *argp2 = 0 ;
51459 int res2 = 0 ;
51460
51461 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51463 if (!SWIG_IsOK(res1)) {
51464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51465 }
51466 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51467 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51468 if (!SWIG_IsOK(res2)) {
51469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51470 }
51471 arg2 = reinterpret_cast< wxWindow * >(argp2);
51472 {
51473 PyThreadState* __tstate = wxPyBeginAllowThreads();
51474 result = (arg1)->GetItemPosition(arg2);
51475 wxPyEndAllowThreads(__tstate);
51476 if (PyErr_Occurred()) SWIG_fail;
51477 }
51478 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51479 return resultobj;
51480 fail:
51481 return NULL;
51482 }
51483
51484
51485 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51486 PyObject *resultobj = 0;
51487 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51488 wxSizer *arg2 = (wxSizer *) 0 ;
51489 wxGBPosition result;
51490 void *argp1 = 0 ;
51491 int res1 = 0 ;
51492 void *argp2 = 0 ;
51493 int res2 = 0 ;
51494
51495 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51497 if (!SWIG_IsOK(res1)) {
51498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51499 }
51500 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51501 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51502 if (!SWIG_IsOK(res2)) {
51503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51504 }
51505 arg2 = reinterpret_cast< wxSizer * >(argp2);
51506 {
51507 PyThreadState* __tstate = wxPyBeginAllowThreads();
51508 result = (arg1)->GetItemPosition(arg2);
51509 wxPyEndAllowThreads(__tstate);
51510 if (PyErr_Occurred()) SWIG_fail;
51511 }
51512 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51513 return resultobj;
51514 fail:
51515 return NULL;
51516 }
51517
51518
51519 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51520 PyObject *resultobj = 0;
51521 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51522 size_t arg2 ;
51523 wxGBPosition result;
51524 void *argp1 = 0 ;
51525 int res1 = 0 ;
51526 size_t val2 ;
51527 int ecode2 = 0 ;
51528
51529 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51531 if (!SWIG_IsOK(res1)) {
51532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51533 }
51534 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51535 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51536 if (!SWIG_IsOK(ecode2)) {
51537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51538 }
51539 arg2 = static_cast< size_t >(val2);
51540 {
51541 PyThreadState* __tstate = wxPyBeginAllowThreads();
51542 result = (arg1)->GetItemPosition(arg2);
51543 wxPyEndAllowThreads(__tstate);
51544 if (PyErr_Occurred()) SWIG_fail;
51545 }
51546 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51547 return resultobj;
51548 fail:
51549 return NULL;
51550 }
51551
51552
51553 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51554 int argc;
51555 PyObject *argv[3];
51556
51557 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51558 --argc;
51559 if (argc == 2) {
51560 int _v = 0;
51561 {
51562 void *vptr = 0;
51563 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51564 _v = SWIG_CheckState(res);
51565 }
51566 if (!_v) goto check_1;
51567 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51568 }
51569 check_1:
51570
51571 if (argc == 2) {
51572 int _v = 0;
51573 {
51574 void *vptr = 0;
51575 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51576 _v = SWIG_CheckState(res);
51577 }
51578 if (!_v) goto check_2;
51579 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51580 }
51581 check_2:
51582
51583 if (argc == 2) {
51584 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51585 }
51586
51587 fail:
51588 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51589 return NULL;
51590 }
51591
51592
51593 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51594 PyObject *resultobj = 0;
51595 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51596 wxWindow *arg2 = (wxWindow *) 0 ;
51597 wxGBPosition *arg3 = 0 ;
51598 bool result;
51599 void *argp1 = 0 ;
51600 int res1 = 0 ;
51601 void *argp2 = 0 ;
51602 int res2 = 0 ;
51603 wxGBPosition temp3 ;
51604
51605 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51607 if (!SWIG_IsOK(res1)) {
51608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51609 }
51610 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51611 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51612 if (!SWIG_IsOK(res2)) {
51613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51614 }
51615 arg2 = reinterpret_cast< wxWindow * >(argp2);
51616 {
51617 arg3 = &temp3;
51618 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51619 }
51620 {
51621 PyThreadState* __tstate = wxPyBeginAllowThreads();
51622 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51623 wxPyEndAllowThreads(__tstate);
51624 if (PyErr_Occurred()) SWIG_fail;
51625 }
51626 {
51627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51628 }
51629 return resultobj;
51630 fail:
51631 return NULL;
51632 }
51633
51634
51635 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51636 PyObject *resultobj = 0;
51637 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51638 wxSizer *arg2 = (wxSizer *) 0 ;
51639 wxGBPosition *arg3 = 0 ;
51640 bool result;
51641 void *argp1 = 0 ;
51642 int res1 = 0 ;
51643 void *argp2 = 0 ;
51644 int res2 = 0 ;
51645 wxGBPosition temp3 ;
51646
51647 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51649 if (!SWIG_IsOK(res1)) {
51650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51651 }
51652 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51653 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51654 if (!SWIG_IsOK(res2)) {
51655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51656 }
51657 arg2 = reinterpret_cast< wxSizer * >(argp2);
51658 {
51659 arg3 = &temp3;
51660 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51661 }
51662 {
51663 PyThreadState* __tstate = wxPyBeginAllowThreads();
51664 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51665 wxPyEndAllowThreads(__tstate);
51666 if (PyErr_Occurred()) SWIG_fail;
51667 }
51668 {
51669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51670 }
51671 return resultobj;
51672 fail:
51673 return NULL;
51674 }
51675
51676
51677 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51678 PyObject *resultobj = 0;
51679 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51680 size_t arg2 ;
51681 wxGBPosition *arg3 = 0 ;
51682 bool result;
51683 void *argp1 = 0 ;
51684 int res1 = 0 ;
51685 size_t val2 ;
51686 int ecode2 = 0 ;
51687 wxGBPosition temp3 ;
51688
51689 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51691 if (!SWIG_IsOK(res1)) {
51692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51693 }
51694 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51695 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51696 if (!SWIG_IsOK(ecode2)) {
51697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51698 }
51699 arg2 = static_cast< size_t >(val2);
51700 {
51701 arg3 = &temp3;
51702 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51703 }
51704 {
51705 PyThreadState* __tstate = wxPyBeginAllowThreads();
51706 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51707 wxPyEndAllowThreads(__tstate);
51708 if (PyErr_Occurred()) SWIG_fail;
51709 }
51710 {
51711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51712 }
51713 return resultobj;
51714 fail:
51715 return NULL;
51716 }
51717
51718
51719 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51720 int argc;
51721 PyObject *argv[4];
51722
51723 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51724 --argc;
51725 if (argc == 3) {
51726 int _v = 0;
51727 {
51728 void *vptr = 0;
51729 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51730 _v = SWIG_CheckState(res);
51731 }
51732 if (!_v) goto check_1;
51733 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51734 }
51735 check_1:
51736
51737 if (argc == 3) {
51738 int _v = 0;
51739 {
51740 void *vptr = 0;
51741 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51742 _v = SWIG_CheckState(res);
51743 }
51744 if (!_v) goto check_2;
51745 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51746 }
51747 check_2:
51748
51749 if (argc == 3) {
51750 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51751 }
51752
51753 fail:
51754 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51755 return NULL;
51756 }
51757
51758
51759 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51760 PyObject *resultobj = 0;
51761 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51762 wxWindow *arg2 = (wxWindow *) 0 ;
51763 wxGBSpan result;
51764 void *argp1 = 0 ;
51765 int res1 = 0 ;
51766 void *argp2 = 0 ;
51767 int res2 = 0 ;
51768
51769 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51771 if (!SWIG_IsOK(res1)) {
51772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51773 }
51774 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51775 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51776 if (!SWIG_IsOK(res2)) {
51777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51778 }
51779 arg2 = reinterpret_cast< wxWindow * >(argp2);
51780 {
51781 PyThreadState* __tstate = wxPyBeginAllowThreads();
51782 result = (arg1)->GetItemSpan(arg2);
51783 wxPyEndAllowThreads(__tstate);
51784 if (PyErr_Occurred()) SWIG_fail;
51785 }
51786 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51787 return resultobj;
51788 fail:
51789 return NULL;
51790 }
51791
51792
51793 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51794 PyObject *resultobj = 0;
51795 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51796 wxSizer *arg2 = (wxSizer *) 0 ;
51797 wxGBSpan result;
51798 void *argp1 = 0 ;
51799 int res1 = 0 ;
51800 void *argp2 = 0 ;
51801 int res2 = 0 ;
51802
51803 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51805 if (!SWIG_IsOK(res1)) {
51806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51807 }
51808 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51809 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51810 if (!SWIG_IsOK(res2)) {
51811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51812 }
51813 arg2 = reinterpret_cast< wxSizer * >(argp2);
51814 {
51815 PyThreadState* __tstate = wxPyBeginAllowThreads();
51816 result = (arg1)->GetItemSpan(arg2);
51817 wxPyEndAllowThreads(__tstate);
51818 if (PyErr_Occurred()) SWIG_fail;
51819 }
51820 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51821 return resultobj;
51822 fail:
51823 return NULL;
51824 }
51825
51826
51827 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51828 PyObject *resultobj = 0;
51829 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51830 size_t arg2 ;
51831 wxGBSpan result;
51832 void *argp1 = 0 ;
51833 int res1 = 0 ;
51834 size_t val2 ;
51835 int ecode2 = 0 ;
51836
51837 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51839 if (!SWIG_IsOK(res1)) {
51840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51841 }
51842 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51843 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51844 if (!SWIG_IsOK(ecode2)) {
51845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51846 }
51847 arg2 = static_cast< size_t >(val2);
51848 {
51849 PyThreadState* __tstate = wxPyBeginAllowThreads();
51850 result = (arg1)->GetItemSpan(arg2);
51851 wxPyEndAllowThreads(__tstate);
51852 if (PyErr_Occurred()) SWIG_fail;
51853 }
51854 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51855 return resultobj;
51856 fail:
51857 return NULL;
51858 }
51859
51860
51861 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51862 int argc;
51863 PyObject *argv[3];
51864
51865 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51866 --argc;
51867 if (argc == 2) {
51868 int _v = 0;
51869 {
51870 void *vptr = 0;
51871 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51872 _v = SWIG_CheckState(res);
51873 }
51874 if (!_v) goto check_1;
51875 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51876 }
51877 check_1:
51878
51879 if (argc == 2) {
51880 int _v = 0;
51881 {
51882 void *vptr = 0;
51883 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51884 _v = SWIG_CheckState(res);
51885 }
51886 if (!_v) goto check_2;
51887 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51888 }
51889 check_2:
51890
51891 if (argc == 2) {
51892 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51893 }
51894
51895 fail:
51896 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51897 return NULL;
51898 }
51899
51900
51901 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51902 PyObject *resultobj = 0;
51903 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51904 wxWindow *arg2 = (wxWindow *) 0 ;
51905 wxGBSpan *arg3 = 0 ;
51906 bool result;
51907 void *argp1 = 0 ;
51908 int res1 = 0 ;
51909 void *argp2 = 0 ;
51910 int res2 = 0 ;
51911 wxGBSpan temp3 ;
51912
51913 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51915 if (!SWIG_IsOK(res1)) {
51916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51917 }
51918 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51919 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51920 if (!SWIG_IsOK(res2)) {
51921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51922 }
51923 arg2 = reinterpret_cast< wxWindow * >(argp2);
51924 {
51925 arg3 = &temp3;
51926 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51927 }
51928 {
51929 PyThreadState* __tstate = wxPyBeginAllowThreads();
51930 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51931 wxPyEndAllowThreads(__tstate);
51932 if (PyErr_Occurred()) SWIG_fail;
51933 }
51934 {
51935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51936 }
51937 return resultobj;
51938 fail:
51939 return NULL;
51940 }
51941
51942
51943 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51944 PyObject *resultobj = 0;
51945 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51946 wxSizer *arg2 = (wxSizer *) 0 ;
51947 wxGBSpan *arg3 = 0 ;
51948 bool result;
51949 void *argp1 = 0 ;
51950 int res1 = 0 ;
51951 void *argp2 = 0 ;
51952 int res2 = 0 ;
51953 wxGBSpan temp3 ;
51954
51955 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51957 if (!SWIG_IsOK(res1)) {
51958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51959 }
51960 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51961 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51962 if (!SWIG_IsOK(res2)) {
51963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51964 }
51965 arg2 = reinterpret_cast< wxSizer * >(argp2);
51966 {
51967 arg3 = &temp3;
51968 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51969 }
51970 {
51971 PyThreadState* __tstate = wxPyBeginAllowThreads();
51972 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51973 wxPyEndAllowThreads(__tstate);
51974 if (PyErr_Occurred()) SWIG_fail;
51975 }
51976 {
51977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51978 }
51979 return resultobj;
51980 fail:
51981 return NULL;
51982 }
51983
51984
51985 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51986 PyObject *resultobj = 0;
51987 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51988 size_t arg2 ;
51989 wxGBSpan *arg3 = 0 ;
51990 bool result;
51991 void *argp1 = 0 ;
51992 int res1 = 0 ;
51993 size_t val2 ;
51994 int ecode2 = 0 ;
51995 wxGBSpan temp3 ;
51996
51997 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51999 if (!SWIG_IsOK(res1)) {
52000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52001 }
52002 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52003 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52004 if (!SWIG_IsOK(ecode2)) {
52005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52006 }
52007 arg2 = static_cast< size_t >(val2);
52008 {
52009 arg3 = &temp3;
52010 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52011 }
52012 {
52013 PyThreadState* __tstate = wxPyBeginAllowThreads();
52014 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52015 wxPyEndAllowThreads(__tstate);
52016 if (PyErr_Occurred()) SWIG_fail;
52017 }
52018 {
52019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52020 }
52021 return resultobj;
52022 fail:
52023 return NULL;
52024 }
52025
52026
52027 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52028 int argc;
52029 PyObject *argv[4];
52030
52031 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52032 --argc;
52033 if (argc == 3) {
52034 int _v = 0;
52035 {
52036 void *vptr = 0;
52037 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52038 _v = SWIG_CheckState(res);
52039 }
52040 if (!_v) goto check_1;
52041 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52042 }
52043 check_1:
52044
52045 if (argc == 3) {
52046 int _v = 0;
52047 {
52048 void *vptr = 0;
52049 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52050 _v = SWIG_CheckState(res);
52051 }
52052 if (!_v) goto check_2;
52053 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52054 }
52055 check_2:
52056
52057 if (argc == 3) {
52058 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52059 }
52060
52061 fail:
52062 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52063 return NULL;
52064 }
52065
52066
52067 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52068 PyObject *resultobj = 0;
52069 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52070 wxWindow *arg2 = (wxWindow *) 0 ;
52071 wxGBSizerItem *result = 0 ;
52072 void *argp1 = 0 ;
52073 int res1 = 0 ;
52074 void *argp2 = 0 ;
52075 int res2 = 0 ;
52076
52077 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52079 if (!SWIG_IsOK(res1)) {
52080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52081 }
52082 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52083 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52084 if (!SWIG_IsOK(res2)) {
52085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52086 }
52087 arg2 = reinterpret_cast< wxWindow * >(argp2);
52088 {
52089 PyThreadState* __tstate = wxPyBeginAllowThreads();
52090 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52091 wxPyEndAllowThreads(__tstate);
52092 if (PyErr_Occurred()) SWIG_fail;
52093 }
52094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52095 return resultobj;
52096 fail:
52097 return NULL;
52098 }
52099
52100
52101 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52102 PyObject *resultobj = 0;
52103 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52104 wxSizer *arg2 = (wxSizer *) 0 ;
52105 wxGBSizerItem *result = 0 ;
52106 void *argp1 = 0 ;
52107 int res1 = 0 ;
52108 void *argp2 = 0 ;
52109 int res2 = 0 ;
52110
52111 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52113 if (!SWIG_IsOK(res1)) {
52114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52115 }
52116 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52117 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52118 if (!SWIG_IsOK(res2)) {
52119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52120 }
52121 arg2 = reinterpret_cast< wxSizer * >(argp2);
52122 {
52123 PyThreadState* __tstate = wxPyBeginAllowThreads();
52124 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52125 wxPyEndAllowThreads(__tstate);
52126 if (PyErr_Occurred()) SWIG_fail;
52127 }
52128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52129 return resultobj;
52130 fail:
52131 return NULL;
52132 }
52133
52134
52135 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52136 int argc;
52137 PyObject *argv[3];
52138
52139 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52140 --argc;
52141 if (argc == 2) {
52142 int _v = 0;
52143 {
52144 void *vptr = 0;
52145 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52146 _v = SWIG_CheckState(res);
52147 }
52148 if (!_v) goto check_1;
52149 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52150 }
52151 check_1:
52152
52153 if (argc == 2) {
52154 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52155 }
52156
52157 fail:
52158 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52159 return NULL;
52160 }
52161
52162
52163 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52164 PyObject *resultobj = 0;
52165 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52166 wxGBPosition *arg2 = 0 ;
52167 wxGBSizerItem *result = 0 ;
52168 void *argp1 = 0 ;
52169 int res1 = 0 ;
52170 wxGBPosition temp2 ;
52171 PyObject * obj0 = 0 ;
52172 PyObject * obj1 = 0 ;
52173 char * kwnames[] = {
52174 (char *) "self",(char *) "pos", NULL
52175 };
52176
52177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52179 if (!SWIG_IsOK(res1)) {
52180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52181 }
52182 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52183 {
52184 arg2 = &temp2;
52185 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52186 }
52187 {
52188 PyThreadState* __tstate = wxPyBeginAllowThreads();
52189 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52190 wxPyEndAllowThreads(__tstate);
52191 if (PyErr_Occurred()) SWIG_fail;
52192 }
52193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52194 return resultobj;
52195 fail:
52196 return NULL;
52197 }
52198
52199
52200 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52201 PyObject *resultobj = 0;
52202 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52203 wxPoint *arg2 = 0 ;
52204 wxGBSizerItem *result = 0 ;
52205 void *argp1 = 0 ;
52206 int res1 = 0 ;
52207 wxPoint temp2 ;
52208 PyObject * obj0 = 0 ;
52209 PyObject * obj1 = 0 ;
52210 char * kwnames[] = {
52211 (char *) "self",(char *) "pt", NULL
52212 };
52213
52214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52216 if (!SWIG_IsOK(res1)) {
52217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52218 }
52219 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52220 {
52221 arg2 = &temp2;
52222 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52223 }
52224 {
52225 PyThreadState* __tstate = wxPyBeginAllowThreads();
52226 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52227 wxPyEndAllowThreads(__tstate);
52228 if (PyErr_Occurred()) SWIG_fail;
52229 }
52230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52231 return resultobj;
52232 fail:
52233 return NULL;
52234 }
52235
52236
52237 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52238 PyObject *resultobj = 0;
52239 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52240 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52241 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52242 bool result;
52243 void *argp1 = 0 ;
52244 int res1 = 0 ;
52245 void *argp2 = 0 ;
52246 int res2 = 0 ;
52247 void *argp3 = 0 ;
52248 int res3 = 0 ;
52249 PyObject * obj0 = 0 ;
52250 PyObject * obj1 = 0 ;
52251 PyObject * obj2 = 0 ;
52252 char * kwnames[] = {
52253 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52254 };
52255
52256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52258 if (!SWIG_IsOK(res1)) {
52259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52260 }
52261 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52263 if (!SWIG_IsOK(res2)) {
52264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52265 }
52266 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52267 if (obj2) {
52268 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52269 if (!SWIG_IsOK(res3)) {
52270 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52271 }
52272 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52273 }
52274 {
52275 PyThreadState* __tstate = wxPyBeginAllowThreads();
52276 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52277 wxPyEndAllowThreads(__tstate);
52278 if (PyErr_Occurred()) SWIG_fail;
52279 }
52280 {
52281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52282 }
52283 return resultobj;
52284 fail:
52285 return NULL;
52286 }
52287
52288
52289 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52290 PyObject *resultobj = 0;
52291 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52292 wxGBPosition *arg2 = 0 ;
52293 wxGBSpan *arg3 = 0 ;
52294 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52295 bool result;
52296 void *argp1 = 0 ;
52297 int res1 = 0 ;
52298 wxGBPosition temp2 ;
52299 wxGBSpan temp3 ;
52300 void *argp4 = 0 ;
52301 int res4 = 0 ;
52302 PyObject * obj0 = 0 ;
52303 PyObject * obj1 = 0 ;
52304 PyObject * obj2 = 0 ;
52305 PyObject * obj3 = 0 ;
52306 char * kwnames[] = {
52307 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52308 };
52309
52310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52312 if (!SWIG_IsOK(res1)) {
52313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52314 }
52315 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52316 {
52317 arg2 = &temp2;
52318 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52319 }
52320 {
52321 arg3 = &temp3;
52322 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52323 }
52324 if (obj3) {
52325 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52326 if (!SWIG_IsOK(res4)) {
52327 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52328 }
52329 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52330 }
52331 {
52332 PyThreadState* __tstate = wxPyBeginAllowThreads();
52333 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52334 wxPyEndAllowThreads(__tstate);
52335 if (PyErr_Occurred()) SWIG_fail;
52336 }
52337 {
52338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52339 }
52340 return resultobj;
52341 fail:
52342 return NULL;
52343 }
52344
52345
52346 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52347 PyObject *obj;
52348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52349 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52350 return SWIG_Py_Void();
52351 }
52352
52353 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52354 return SWIG_Python_InitShadowInstance(args);
52355 }
52356
52357 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52358 PyObject *resultobj = 0;
52359 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52360 wxRelationship arg2 ;
52361 wxWindow *arg3 = (wxWindow *) 0 ;
52362 wxEdge arg4 ;
52363 int arg5 = (int) 0 ;
52364 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52365 void *argp1 = 0 ;
52366 int res1 = 0 ;
52367 int val2 ;
52368 int ecode2 = 0 ;
52369 void *argp3 = 0 ;
52370 int res3 = 0 ;
52371 int val4 ;
52372 int ecode4 = 0 ;
52373 int val5 ;
52374 int ecode5 = 0 ;
52375 int val6 ;
52376 int ecode6 = 0 ;
52377 PyObject * obj0 = 0 ;
52378 PyObject * obj1 = 0 ;
52379 PyObject * obj2 = 0 ;
52380 PyObject * obj3 = 0 ;
52381 PyObject * obj4 = 0 ;
52382 PyObject * obj5 = 0 ;
52383 char * kwnames[] = {
52384 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52385 };
52386
52387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52389 if (!SWIG_IsOK(res1)) {
52390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52391 }
52392 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52393 ecode2 = SWIG_AsVal_int(obj1, &val2);
52394 if (!SWIG_IsOK(ecode2)) {
52395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52396 }
52397 arg2 = static_cast< wxRelationship >(val2);
52398 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52399 if (!SWIG_IsOK(res3)) {
52400 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52401 }
52402 arg3 = reinterpret_cast< wxWindow * >(argp3);
52403 ecode4 = SWIG_AsVal_int(obj3, &val4);
52404 if (!SWIG_IsOK(ecode4)) {
52405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52406 }
52407 arg4 = static_cast< wxEdge >(val4);
52408 if (obj4) {
52409 ecode5 = SWIG_AsVal_int(obj4, &val5);
52410 if (!SWIG_IsOK(ecode5)) {
52411 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52412 }
52413 arg5 = static_cast< int >(val5);
52414 }
52415 if (obj5) {
52416 ecode6 = SWIG_AsVal_int(obj5, &val6);
52417 if (!SWIG_IsOK(ecode6)) {
52418 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52419 }
52420 arg6 = static_cast< int >(val6);
52421 }
52422 {
52423 PyThreadState* __tstate = wxPyBeginAllowThreads();
52424 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52425 wxPyEndAllowThreads(__tstate);
52426 if (PyErr_Occurred()) SWIG_fail;
52427 }
52428 resultobj = SWIG_Py_Void();
52429 return resultobj;
52430 fail:
52431 return NULL;
52432 }
52433
52434
52435 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52436 PyObject *resultobj = 0;
52437 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52438 wxWindow *arg2 = (wxWindow *) 0 ;
52439 int arg3 = (int) 0 ;
52440 void *argp1 = 0 ;
52441 int res1 = 0 ;
52442 void *argp2 = 0 ;
52443 int res2 = 0 ;
52444 int val3 ;
52445 int ecode3 = 0 ;
52446 PyObject * obj0 = 0 ;
52447 PyObject * obj1 = 0 ;
52448 PyObject * obj2 = 0 ;
52449 char * kwnames[] = {
52450 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52451 };
52452
52453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52455 if (!SWIG_IsOK(res1)) {
52456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52457 }
52458 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52459 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52460 if (!SWIG_IsOK(res2)) {
52461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52462 }
52463 arg2 = reinterpret_cast< wxWindow * >(argp2);
52464 if (obj2) {
52465 ecode3 = SWIG_AsVal_int(obj2, &val3);
52466 if (!SWIG_IsOK(ecode3)) {
52467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52468 }
52469 arg3 = static_cast< int >(val3);
52470 }
52471 {
52472 PyThreadState* __tstate = wxPyBeginAllowThreads();
52473 (arg1)->LeftOf(arg2,arg3);
52474 wxPyEndAllowThreads(__tstate);
52475 if (PyErr_Occurred()) SWIG_fail;
52476 }
52477 resultobj = SWIG_Py_Void();
52478 return resultobj;
52479 fail:
52480 return NULL;
52481 }
52482
52483
52484 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52485 PyObject *resultobj = 0;
52486 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52487 wxWindow *arg2 = (wxWindow *) 0 ;
52488 int arg3 = (int) 0 ;
52489 void *argp1 = 0 ;
52490 int res1 = 0 ;
52491 void *argp2 = 0 ;
52492 int res2 = 0 ;
52493 int val3 ;
52494 int ecode3 = 0 ;
52495 PyObject * obj0 = 0 ;
52496 PyObject * obj1 = 0 ;
52497 PyObject * obj2 = 0 ;
52498 char * kwnames[] = {
52499 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52500 };
52501
52502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52504 if (!SWIG_IsOK(res1)) {
52505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52506 }
52507 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52508 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52509 if (!SWIG_IsOK(res2)) {
52510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52511 }
52512 arg2 = reinterpret_cast< wxWindow * >(argp2);
52513 if (obj2) {
52514 ecode3 = SWIG_AsVal_int(obj2, &val3);
52515 if (!SWIG_IsOK(ecode3)) {
52516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52517 }
52518 arg3 = static_cast< int >(val3);
52519 }
52520 {
52521 PyThreadState* __tstate = wxPyBeginAllowThreads();
52522 (arg1)->RightOf(arg2,arg3);
52523 wxPyEndAllowThreads(__tstate);
52524 if (PyErr_Occurred()) SWIG_fail;
52525 }
52526 resultobj = SWIG_Py_Void();
52527 return resultobj;
52528 fail:
52529 return NULL;
52530 }
52531
52532
52533 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52534 PyObject *resultobj = 0;
52535 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52536 wxWindow *arg2 = (wxWindow *) 0 ;
52537 int arg3 = (int) 0 ;
52538 void *argp1 = 0 ;
52539 int res1 = 0 ;
52540 void *argp2 = 0 ;
52541 int res2 = 0 ;
52542 int val3 ;
52543 int ecode3 = 0 ;
52544 PyObject * obj0 = 0 ;
52545 PyObject * obj1 = 0 ;
52546 PyObject * obj2 = 0 ;
52547 char * kwnames[] = {
52548 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52549 };
52550
52551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52553 if (!SWIG_IsOK(res1)) {
52554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52555 }
52556 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52558 if (!SWIG_IsOK(res2)) {
52559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52560 }
52561 arg2 = reinterpret_cast< wxWindow * >(argp2);
52562 if (obj2) {
52563 ecode3 = SWIG_AsVal_int(obj2, &val3);
52564 if (!SWIG_IsOK(ecode3)) {
52565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52566 }
52567 arg3 = static_cast< int >(val3);
52568 }
52569 {
52570 PyThreadState* __tstate = wxPyBeginAllowThreads();
52571 (arg1)->Above(arg2,arg3);
52572 wxPyEndAllowThreads(__tstate);
52573 if (PyErr_Occurred()) SWIG_fail;
52574 }
52575 resultobj = SWIG_Py_Void();
52576 return resultobj;
52577 fail:
52578 return NULL;
52579 }
52580
52581
52582 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52583 PyObject *resultobj = 0;
52584 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52585 wxWindow *arg2 = (wxWindow *) 0 ;
52586 int arg3 = (int) 0 ;
52587 void *argp1 = 0 ;
52588 int res1 = 0 ;
52589 void *argp2 = 0 ;
52590 int res2 = 0 ;
52591 int val3 ;
52592 int ecode3 = 0 ;
52593 PyObject * obj0 = 0 ;
52594 PyObject * obj1 = 0 ;
52595 PyObject * obj2 = 0 ;
52596 char * kwnames[] = {
52597 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52598 };
52599
52600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52602 if (!SWIG_IsOK(res1)) {
52603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52604 }
52605 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52606 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52607 if (!SWIG_IsOK(res2)) {
52608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52609 }
52610 arg2 = reinterpret_cast< wxWindow * >(argp2);
52611 if (obj2) {
52612 ecode3 = SWIG_AsVal_int(obj2, &val3);
52613 if (!SWIG_IsOK(ecode3)) {
52614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52615 }
52616 arg3 = static_cast< int >(val3);
52617 }
52618 {
52619 PyThreadState* __tstate = wxPyBeginAllowThreads();
52620 (arg1)->Below(arg2,arg3);
52621 wxPyEndAllowThreads(__tstate);
52622 if (PyErr_Occurred()) SWIG_fail;
52623 }
52624 resultobj = SWIG_Py_Void();
52625 return resultobj;
52626 fail:
52627 return NULL;
52628 }
52629
52630
52631 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52632 PyObject *resultobj = 0;
52633 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52634 wxWindow *arg2 = (wxWindow *) 0 ;
52635 wxEdge arg3 ;
52636 int arg4 = (int) 0 ;
52637 void *argp1 = 0 ;
52638 int res1 = 0 ;
52639 void *argp2 = 0 ;
52640 int res2 = 0 ;
52641 int val3 ;
52642 int ecode3 = 0 ;
52643 int val4 ;
52644 int ecode4 = 0 ;
52645 PyObject * obj0 = 0 ;
52646 PyObject * obj1 = 0 ;
52647 PyObject * obj2 = 0 ;
52648 PyObject * obj3 = 0 ;
52649 char * kwnames[] = {
52650 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52651 };
52652
52653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52655 if (!SWIG_IsOK(res1)) {
52656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52657 }
52658 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52660 if (!SWIG_IsOK(res2)) {
52661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52662 }
52663 arg2 = reinterpret_cast< wxWindow * >(argp2);
52664 ecode3 = SWIG_AsVal_int(obj2, &val3);
52665 if (!SWIG_IsOK(ecode3)) {
52666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52667 }
52668 arg3 = static_cast< wxEdge >(val3);
52669 if (obj3) {
52670 ecode4 = SWIG_AsVal_int(obj3, &val4);
52671 if (!SWIG_IsOK(ecode4)) {
52672 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52673 }
52674 arg4 = static_cast< int >(val4);
52675 }
52676 {
52677 PyThreadState* __tstate = wxPyBeginAllowThreads();
52678 (arg1)->SameAs(arg2,arg3,arg4);
52679 wxPyEndAllowThreads(__tstate);
52680 if (PyErr_Occurred()) SWIG_fail;
52681 }
52682 resultobj = SWIG_Py_Void();
52683 return resultobj;
52684 fail:
52685 return NULL;
52686 }
52687
52688
52689 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52690 PyObject *resultobj = 0;
52691 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52692 wxWindow *arg2 = (wxWindow *) 0 ;
52693 wxEdge arg3 ;
52694 int arg4 ;
52695 void *argp1 = 0 ;
52696 int res1 = 0 ;
52697 void *argp2 = 0 ;
52698 int res2 = 0 ;
52699 int val3 ;
52700 int ecode3 = 0 ;
52701 int val4 ;
52702 int ecode4 = 0 ;
52703 PyObject * obj0 = 0 ;
52704 PyObject * obj1 = 0 ;
52705 PyObject * obj2 = 0 ;
52706 PyObject * obj3 = 0 ;
52707 char * kwnames[] = {
52708 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52709 };
52710
52711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52713 if (!SWIG_IsOK(res1)) {
52714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52715 }
52716 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52717 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52718 if (!SWIG_IsOK(res2)) {
52719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52720 }
52721 arg2 = reinterpret_cast< wxWindow * >(argp2);
52722 ecode3 = SWIG_AsVal_int(obj2, &val3);
52723 if (!SWIG_IsOK(ecode3)) {
52724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52725 }
52726 arg3 = static_cast< wxEdge >(val3);
52727 ecode4 = SWIG_AsVal_int(obj3, &val4);
52728 if (!SWIG_IsOK(ecode4)) {
52729 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52730 }
52731 arg4 = static_cast< int >(val4);
52732 {
52733 PyThreadState* __tstate = wxPyBeginAllowThreads();
52734 (arg1)->PercentOf(arg2,arg3,arg4);
52735 wxPyEndAllowThreads(__tstate);
52736 if (PyErr_Occurred()) SWIG_fail;
52737 }
52738 resultobj = SWIG_Py_Void();
52739 return resultobj;
52740 fail:
52741 return NULL;
52742 }
52743
52744
52745 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52746 PyObject *resultobj = 0;
52747 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52748 int arg2 ;
52749 void *argp1 = 0 ;
52750 int res1 = 0 ;
52751 int val2 ;
52752 int ecode2 = 0 ;
52753 PyObject * obj0 = 0 ;
52754 PyObject * obj1 = 0 ;
52755 char * kwnames[] = {
52756 (char *) "self",(char *) "val", NULL
52757 };
52758
52759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52761 if (!SWIG_IsOK(res1)) {
52762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52763 }
52764 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52765 ecode2 = SWIG_AsVal_int(obj1, &val2);
52766 if (!SWIG_IsOK(ecode2)) {
52767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52768 }
52769 arg2 = static_cast< int >(val2);
52770 {
52771 PyThreadState* __tstate = wxPyBeginAllowThreads();
52772 (arg1)->Absolute(arg2);
52773 wxPyEndAllowThreads(__tstate);
52774 if (PyErr_Occurred()) SWIG_fail;
52775 }
52776 resultobj = SWIG_Py_Void();
52777 return resultobj;
52778 fail:
52779 return NULL;
52780 }
52781
52782
52783 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52784 PyObject *resultobj = 0;
52785 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52786 void *argp1 = 0 ;
52787 int res1 = 0 ;
52788 PyObject *swig_obj[1] ;
52789
52790 if (!args) SWIG_fail;
52791 swig_obj[0] = args;
52792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52793 if (!SWIG_IsOK(res1)) {
52794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52795 }
52796 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52797 {
52798 PyThreadState* __tstate = wxPyBeginAllowThreads();
52799 (arg1)->Unconstrained();
52800 wxPyEndAllowThreads(__tstate);
52801 if (PyErr_Occurred()) SWIG_fail;
52802 }
52803 resultobj = SWIG_Py_Void();
52804 return resultobj;
52805 fail:
52806 return NULL;
52807 }
52808
52809
52810 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52811 PyObject *resultobj = 0;
52812 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52813 void *argp1 = 0 ;
52814 int res1 = 0 ;
52815 PyObject *swig_obj[1] ;
52816
52817 if (!args) SWIG_fail;
52818 swig_obj[0] = args;
52819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52820 if (!SWIG_IsOK(res1)) {
52821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52822 }
52823 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52824 {
52825 PyThreadState* __tstate = wxPyBeginAllowThreads();
52826 (arg1)->AsIs();
52827 wxPyEndAllowThreads(__tstate);
52828 if (PyErr_Occurred()) SWIG_fail;
52829 }
52830 resultobj = SWIG_Py_Void();
52831 return resultobj;
52832 fail:
52833 return NULL;
52834 }
52835
52836
52837 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52838 PyObject *resultobj = 0;
52839 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52840 wxWindow *result = 0 ;
52841 void *argp1 = 0 ;
52842 int res1 = 0 ;
52843 PyObject *swig_obj[1] ;
52844
52845 if (!args) SWIG_fail;
52846 swig_obj[0] = args;
52847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52848 if (!SWIG_IsOK(res1)) {
52849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52850 }
52851 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52852 {
52853 PyThreadState* __tstate = wxPyBeginAllowThreads();
52854 result = (wxWindow *)(arg1)->GetOtherWindow();
52855 wxPyEndAllowThreads(__tstate);
52856 if (PyErr_Occurred()) SWIG_fail;
52857 }
52858 {
52859 resultobj = wxPyMake_wxObject(result, 0);
52860 }
52861 return resultobj;
52862 fail:
52863 return NULL;
52864 }
52865
52866
52867 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52868 PyObject *resultobj = 0;
52869 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52870 wxEdge result;
52871 void *argp1 = 0 ;
52872 int res1 = 0 ;
52873 PyObject *swig_obj[1] ;
52874
52875 if (!args) SWIG_fail;
52876 swig_obj[0] = args;
52877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52878 if (!SWIG_IsOK(res1)) {
52879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52880 }
52881 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52882 {
52883 PyThreadState* __tstate = wxPyBeginAllowThreads();
52884 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52885 wxPyEndAllowThreads(__tstate);
52886 if (PyErr_Occurred()) SWIG_fail;
52887 }
52888 resultobj = SWIG_From_int(static_cast< int >(result));
52889 return resultobj;
52890 fail:
52891 return NULL;
52892 }
52893
52894
52895 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52896 PyObject *resultobj = 0;
52897 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52898 wxEdge arg2 ;
52899 void *argp1 = 0 ;
52900 int res1 = 0 ;
52901 int val2 ;
52902 int ecode2 = 0 ;
52903 PyObject * obj0 = 0 ;
52904 PyObject * obj1 = 0 ;
52905 char * kwnames[] = {
52906 (char *) "self",(char *) "which", NULL
52907 };
52908
52909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52911 if (!SWIG_IsOK(res1)) {
52912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52913 }
52914 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52915 ecode2 = SWIG_AsVal_int(obj1, &val2);
52916 if (!SWIG_IsOK(ecode2)) {
52917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52918 }
52919 arg2 = static_cast< wxEdge >(val2);
52920 {
52921 PyThreadState* __tstate = wxPyBeginAllowThreads();
52922 (arg1)->SetEdge(arg2);
52923 wxPyEndAllowThreads(__tstate);
52924 if (PyErr_Occurred()) SWIG_fail;
52925 }
52926 resultobj = SWIG_Py_Void();
52927 return resultobj;
52928 fail:
52929 return NULL;
52930 }
52931
52932
52933 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52934 PyObject *resultobj = 0;
52935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52936 int arg2 ;
52937 void *argp1 = 0 ;
52938 int res1 = 0 ;
52939 int val2 ;
52940 int ecode2 = 0 ;
52941 PyObject * obj0 = 0 ;
52942 PyObject * obj1 = 0 ;
52943 char * kwnames[] = {
52944 (char *) "self",(char *) "v", NULL
52945 };
52946
52947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52949 if (!SWIG_IsOK(res1)) {
52950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52951 }
52952 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52953 ecode2 = SWIG_AsVal_int(obj1, &val2);
52954 if (!SWIG_IsOK(ecode2)) {
52955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52956 }
52957 arg2 = static_cast< int >(val2);
52958 {
52959 PyThreadState* __tstate = wxPyBeginAllowThreads();
52960 (arg1)->SetValue(arg2);
52961 wxPyEndAllowThreads(__tstate);
52962 if (PyErr_Occurred()) SWIG_fail;
52963 }
52964 resultobj = SWIG_Py_Void();
52965 return resultobj;
52966 fail:
52967 return NULL;
52968 }
52969
52970
52971 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52972 PyObject *resultobj = 0;
52973 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52974 int result;
52975 void *argp1 = 0 ;
52976 int res1 = 0 ;
52977 PyObject *swig_obj[1] ;
52978
52979 if (!args) SWIG_fail;
52980 swig_obj[0] = args;
52981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52982 if (!SWIG_IsOK(res1)) {
52983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52984 }
52985 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52986 {
52987 PyThreadState* __tstate = wxPyBeginAllowThreads();
52988 result = (int)(arg1)->GetMargin();
52989 wxPyEndAllowThreads(__tstate);
52990 if (PyErr_Occurred()) SWIG_fail;
52991 }
52992 resultobj = SWIG_From_int(static_cast< int >(result));
52993 return resultobj;
52994 fail:
52995 return NULL;
52996 }
52997
52998
52999 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53000 PyObject *resultobj = 0;
53001 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53002 int arg2 ;
53003 void *argp1 = 0 ;
53004 int res1 = 0 ;
53005 int val2 ;
53006 int ecode2 = 0 ;
53007 PyObject * obj0 = 0 ;
53008 PyObject * obj1 = 0 ;
53009 char * kwnames[] = {
53010 (char *) "self",(char *) "m", NULL
53011 };
53012
53013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53015 if (!SWIG_IsOK(res1)) {
53016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53017 }
53018 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53019 ecode2 = SWIG_AsVal_int(obj1, &val2);
53020 if (!SWIG_IsOK(ecode2)) {
53021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53022 }
53023 arg2 = static_cast< int >(val2);
53024 {
53025 PyThreadState* __tstate = wxPyBeginAllowThreads();
53026 (arg1)->SetMargin(arg2);
53027 wxPyEndAllowThreads(__tstate);
53028 if (PyErr_Occurred()) SWIG_fail;
53029 }
53030 resultobj = SWIG_Py_Void();
53031 return resultobj;
53032 fail:
53033 return NULL;
53034 }
53035
53036
53037 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53038 PyObject *resultobj = 0;
53039 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53040 int result;
53041 void *argp1 = 0 ;
53042 int res1 = 0 ;
53043 PyObject *swig_obj[1] ;
53044
53045 if (!args) SWIG_fail;
53046 swig_obj[0] = args;
53047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53048 if (!SWIG_IsOK(res1)) {
53049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53050 }
53051 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53052 {
53053 PyThreadState* __tstate = wxPyBeginAllowThreads();
53054 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53055 wxPyEndAllowThreads(__tstate);
53056 if (PyErr_Occurred()) SWIG_fail;
53057 }
53058 resultobj = SWIG_From_int(static_cast< int >(result));
53059 return resultobj;
53060 fail:
53061 return NULL;
53062 }
53063
53064
53065 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53066 PyObject *resultobj = 0;
53067 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53068 int result;
53069 void *argp1 = 0 ;
53070 int res1 = 0 ;
53071 PyObject *swig_obj[1] ;
53072
53073 if (!args) SWIG_fail;
53074 swig_obj[0] = args;
53075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53076 if (!SWIG_IsOK(res1)) {
53077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53078 }
53079 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53080 {
53081 PyThreadState* __tstate = wxPyBeginAllowThreads();
53082 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53083 wxPyEndAllowThreads(__tstate);
53084 if (PyErr_Occurred()) SWIG_fail;
53085 }
53086 resultobj = SWIG_From_int(static_cast< int >(result));
53087 return resultobj;
53088 fail:
53089 return NULL;
53090 }
53091
53092
53093 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53094 PyObject *resultobj = 0;
53095 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53096 int result;
53097 void *argp1 = 0 ;
53098 int res1 = 0 ;
53099 PyObject *swig_obj[1] ;
53100
53101 if (!args) SWIG_fail;
53102 swig_obj[0] = args;
53103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53104 if (!SWIG_IsOK(res1)) {
53105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53106 }
53107 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53108 {
53109 PyThreadState* __tstate = wxPyBeginAllowThreads();
53110 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53111 wxPyEndAllowThreads(__tstate);
53112 if (PyErr_Occurred()) SWIG_fail;
53113 }
53114 resultobj = SWIG_From_int(static_cast< int >(result));
53115 return resultobj;
53116 fail:
53117 return NULL;
53118 }
53119
53120
53121 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53122 PyObject *resultobj = 0;
53123 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53124 bool result;
53125 void *argp1 = 0 ;
53126 int res1 = 0 ;
53127 PyObject *swig_obj[1] ;
53128
53129 if (!args) SWIG_fail;
53130 swig_obj[0] = args;
53131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53132 if (!SWIG_IsOK(res1)) {
53133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53134 }
53135 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53136 {
53137 PyThreadState* __tstate = wxPyBeginAllowThreads();
53138 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53139 wxPyEndAllowThreads(__tstate);
53140 if (PyErr_Occurred()) SWIG_fail;
53141 }
53142 {
53143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53144 }
53145 return resultobj;
53146 fail:
53147 return NULL;
53148 }
53149
53150
53151 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53152 PyObject *resultobj = 0;
53153 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53154 bool arg2 ;
53155 void *argp1 = 0 ;
53156 int res1 = 0 ;
53157 bool val2 ;
53158 int ecode2 = 0 ;
53159 PyObject * obj0 = 0 ;
53160 PyObject * obj1 = 0 ;
53161 char * kwnames[] = {
53162 (char *) "self",(char *) "d", NULL
53163 };
53164
53165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53167 if (!SWIG_IsOK(res1)) {
53168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53169 }
53170 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53171 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53172 if (!SWIG_IsOK(ecode2)) {
53173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53174 }
53175 arg2 = static_cast< bool >(val2);
53176 {
53177 PyThreadState* __tstate = wxPyBeginAllowThreads();
53178 (arg1)->SetDone(arg2);
53179 wxPyEndAllowThreads(__tstate);
53180 if (PyErr_Occurred()) SWIG_fail;
53181 }
53182 resultobj = SWIG_Py_Void();
53183 return resultobj;
53184 fail:
53185 return NULL;
53186 }
53187
53188
53189 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53190 PyObject *resultobj = 0;
53191 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53192 wxRelationship result;
53193 void *argp1 = 0 ;
53194 int res1 = 0 ;
53195 PyObject *swig_obj[1] ;
53196
53197 if (!args) SWIG_fail;
53198 swig_obj[0] = args;
53199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53200 if (!SWIG_IsOK(res1)) {
53201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53202 }
53203 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53204 {
53205 PyThreadState* __tstate = wxPyBeginAllowThreads();
53206 result = (wxRelationship)(arg1)->GetRelationship();
53207 wxPyEndAllowThreads(__tstate);
53208 if (PyErr_Occurred()) SWIG_fail;
53209 }
53210 resultobj = SWIG_From_int(static_cast< int >(result));
53211 return resultobj;
53212 fail:
53213 return NULL;
53214 }
53215
53216
53217 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53218 PyObject *resultobj = 0;
53219 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53220 wxRelationship arg2 ;
53221 void *argp1 = 0 ;
53222 int res1 = 0 ;
53223 int val2 ;
53224 int ecode2 = 0 ;
53225 PyObject * obj0 = 0 ;
53226 PyObject * obj1 = 0 ;
53227 char * kwnames[] = {
53228 (char *) "self",(char *) "r", NULL
53229 };
53230
53231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53233 if (!SWIG_IsOK(res1)) {
53234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53235 }
53236 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53237 ecode2 = SWIG_AsVal_int(obj1, &val2);
53238 if (!SWIG_IsOK(ecode2)) {
53239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53240 }
53241 arg2 = static_cast< wxRelationship >(val2);
53242 {
53243 PyThreadState* __tstate = wxPyBeginAllowThreads();
53244 (arg1)->SetRelationship(arg2);
53245 wxPyEndAllowThreads(__tstate);
53246 if (PyErr_Occurred()) SWIG_fail;
53247 }
53248 resultobj = SWIG_Py_Void();
53249 return resultobj;
53250 fail:
53251 return NULL;
53252 }
53253
53254
53255 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53256 PyObject *resultobj = 0;
53257 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53258 wxWindow *arg2 = (wxWindow *) 0 ;
53259 bool result;
53260 void *argp1 = 0 ;
53261 int res1 = 0 ;
53262 void *argp2 = 0 ;
53263 int res2 = 0 ;
53264 PyObject * obj0 = 0 ;
53265 PyObject * obj1 = 0 ;
53266 char * kwnames[] = {
53267 (char *) "self",(char *) "otherW", NULL
53268 };
53269
53270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53272 if (!SWIG_IsOK(res1)) {
53273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53274 }
53275 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53277 if (!SWIG_IsOK(res2)) {
53278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53279 }
53280 arg2 = reinterpret_cast< wxWindow * >(argp2);
53281 {
53282 PyThreadState* __tstate = wxPyBeginAllowThreads();
53283 result = (bool)(arg1)->ResetIfWin(arg2);
53284 wxPyEndAllowThreads(__tstate);
53285 if (PyErr_Occurred()) SWIG_fail;
53286 }
53287 {
53288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53289 }
53290 return resultobj;
53291 fail:
53292 return NULL;
53293 }
53294
53295
53296 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53297 PyObject *resultobj = 0;
53298 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53299 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53300 wxWindow *arg3 = (wxWindow *) 0 ;
53301 bool result;
53302 void *argp1 = 0 ;
53303 int res1 = 0 ;
53304 void *argp2 = 0 ;
53305 int res2 = 0 ;
53306 void *argp3 = 0 ;
53307 int res3 = 0 ;
53308 PyObject * obj0 = 0 ;
53309 PyObject * obj1 = 0 ;
53310 PyObject * obj2 = 0 ;
53311 char * kwnames[] = {
53312 (char *) "self",(char *) "constraints",(char *) "win", NULL
53313 };
53314
53315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53317 if (!SWIG_IsOK(res1)) {
53318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53319 }
53320 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53322 if (!SWIG_IsOK(res2)) {
53323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53324 }
53325 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53326 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53327 if (!SWIG_IsOK(res3)) {
53328 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53329 }
53330 arg3 = reinterpret_cast< wxWindow * >(argp3);
53331 {
53332 PyThreadState* __tstate = wxPyBeginAllowThreads();
53333 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53334 wxPyEndAllowThreads(__tstate);
53335 if (PyErr_Occurred()) SWIG_fail;
53336 }
53337 {
53338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53339 }
53340 return resultobj;
53341 fail:
53342 return NULL;
53343 }
53344
53345
53346 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53347 PyObject *resultobj = 0;
53348 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53349 wxEdge arg2 ;
53350 wxWindow *arg3 = (wxWindow *) 0 ;
53351 wxWindow *arg4 = (wxWindow *) 0 ;
53352 int result;
53353 void *argp1 = 0 ;
53354 int res1 = 0 ;
53355 int val2 ;
53356 int ecode2 = 0 ;
53357 void *argp3 = 0 ;
53358 int res3 = 0 ;
53359 void *argp4 = 0 ;
53360 int res4 = 0 ;
53361 PyObject * obj0 = 0 ;
53362 PyObject * obj1 = 0 ;
53363 PyObject * obj2 = 0 ;
53364 PyObject * obj3 = 0 ;
53365 char * kwnames[] = {
53366 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53367 };
53368
53369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53371 if (!SWIG_IsOK(res1)) {
53372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53373 }
53374 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53375 ecode2 = SWIG_AsVal_int(obj1, &val2);
53376 if (!SWIG_IsOK(ecode2)) {
53377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53378 }
53379 arg2 = static_cast< wxEdge >(val2);
53380 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53381 if (!SWIG_IsOK(res3)) {
53382 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53383 }
53384 arg3 = reinterpret_cast< wxWindow * >(argp3);
53385 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53386 if (!SWIG_IsOK(res4)) {
53387 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53388 }
53389 arg4 = reinterpret_cast< wxWindow * >(argp4);
53390 {
53391 PyThreadState* __tstate = wxPyBeginAllowThreads();
53392 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53393 wxPyEndAllowThreads(__tstate);
53394 if (PyErr_Occurred()) SWIG_fail;
53395 }
53396 resultobj = SWIG_From_int(static_cast< int >(result));
53397 return resultobj;
53398 fail:
53399 return NULL;
53400 }
53401
53402
53403 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53404 PyObject *obj;
53405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53406 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53407 return SWIG_Py_Void();
53408 }
53409
53410 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53411 PyObject *resultobj = 0;
53412 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53413 wxIndividualLayoutConstraint *result = 0 ;
53414 void *argp1 = 0 ;
53415 int res1 = 0 ;
53416 PyObject *swig_obj[1] ;
53417
53418 if (!args) SWIG_fail;
53419 swig_obj[0] = args;
53420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53421 if (!SWIG_IsOK(res1)) {
53422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53423 }
53424 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53425 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53427 return resultobj;
53428 fail:
53429 return NULL;
53430 }
53431
53432
53433 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53434 PyObject *resultobj = 0;
53435 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53436 wxIndividualLayoutConstraint *result = 0 ;
53437 void *argp1 = 0 ;
53438 int res1 = 0 ;
53439 PyObject *swig_obj[1] ;
53440
53441 if (!args) SWIG_fail;
53442 swig_obj[0] = args;
53443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53444 if (!SWIG_IsOK(res1)) {
53445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53446 }
53447 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53448 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53450 return resultobj;
53451 fail:
53452 return NULL;
53453 }
53454
53455
53456 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53457 PyObject *resultobj = 0;
53458 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53459 wxIndividualLayoutConstraint *result = 0 ;
53460 void *argp1 = 0 ;
53461 int res1 = 0 ;
53462 PyObject *swig_obj[1] ;
53463
53464 if (!args) SWIG_fail;
53465 swig_obj[0] = args;
53466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53467 if (!SWIG_IsOK(res1)) {
53468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53469 }
53470 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53471 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53473 return resultobj;
53474 fail:
53475 return NULL;
53476 }
53477
53478
53479 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53480 PyObject *resultobj = 0;
53481 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53482 wxIndividualLayoutConstraint *result = 0 ;
53483 void *argp1 = 0 ;
53484 int res1 = 0 ;
53485 PyObject *swig_obj[1] ;
53486
53487 if (!args) SWIG_fail;
53488 swig_obj[0] = args;
53489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53490 if (!SWIG_IsOK(res1)) {
53491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53492 }
53493 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53494 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53496 return resultobj;
53497 fail:
53498 return NULL;
53499 }
53500
53501
53502 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53503 PyObject *resultobj = 0;
53504 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53505 wxIndividualLayoutConstraint *result = 0 ;
53506 void *argp1 = 0 ;
53507 int res1 = 0 ;
53508 PyObject *swig_obj[1] ;
53509
53510 if (!args) SWIG_fail;
53511 swig_obj[0] = args;
53512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53513 if (!SWIG_IsOK(res1)) {
53514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53515 }
53516 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53517 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53519 return resultobj;
53520 fail:
53521 return NULL;
53522 }
53523
53524
53525 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53526 PyObject *resultobj = 0;
53527 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53528 wxIndividualLayoutConstraint *result = 0 ;
53529 void *argp1 = 0 ;
53530 int res1 = 0 ;
53531 PyObject *swig_obj[1] ;
53532
53533 if (!args) SWIG_fail;
53534 swig_obj[0] = args;
53535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53536 if (!SWIG_IsOK(res1)) {
53537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53538 }
53539 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53540 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53542 return resultobj;
53543 fail:
53544 return NULL;
53545 }
53546
53547
53548 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53549 PyObject *resultobj = 0;
53550 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53551 wxIndividualLayoutConstraint *result = 0 ;
53552 void *argp1 = 0 ;
53553 int res1 = 0 ;
53554 PyObject *swig_obj[1] ;
53555
53556 if (!args) SWIG_fail;
53557 swig_obj[0] = args;
53558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53559 if (!SWIG_IsOK(res1)) {
53560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53561 }
53562 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53563 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53565 return resultobj;
53566 fail:
53567 return NULL;
53568 }
53569
53570
53571 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53572 PyObject *resultobj = 0;
53573 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53574 wxIndividualLayoutConstraint *result = 0 ;
53575 void *argp1 = 0 ;
53576 int res1 = 0 ;
53577 PyObject *swig_obj[1] ;
53578
53579 if (!args) SWIG_fail;
53580 swig_obj[0] = args;
53581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53582 if (!SWIG_IsOK(res1)) {
53583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53584 }
53585 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53586 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53588 return resultobj;
53589 fail:
53590 return NULL;
53591 }
53592
53593
53594 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53595 PyObject *resultobj = 0;
53596 wxLayoutConstraints *result = 0 ;
53597
53598 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53599 {
53600 PyThreadState* __tstate = wxPyBeginAllowThreads();
53601 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53602 wxPyEndAllowThreads(__tstate);
53603 if (PyErr_Occurred()) SWIG_fail;
53604 }
53605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53606 return resultobj;
53607 fail:
53608 return NULL;
53609 }
53610
53611
53612 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53613 PyObject *resultobj = 0;
53614 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53615 void *argp1 = 0 ;
53616 int res1 = 0 ;
53617 PyObject *swig_obj[1] ;
53618
53619 if (!args) SWIG_fail;
53620 swig_obj[0] = args;
53621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53622 if (!SWIG_IsOK(res1)) {
53623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53624 }
53625 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53626 {
53627 PyThreadState* __tstate = wxPyBeginAllowThreads();
53628 delete arg1;
53629
53630 wxPyEndAllowThreads(__tstate);
53631 if (PyErr_Occurred()) SWIG_fail;
53632 }
53633 resultobj = SWIG_Py_Void();
53634 return resultobj;
53635 fail:
53636 return NULL;
53637 }
53638
53639
53640 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53641 PyObject *resultobj = 0;
53642 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53643 wxWindow *arg2 = (wxWindow *) 0 ;
53644 int *arg3 = (int *) 0 ;
53645 bool result;
53646 void *argp1 = 0 ;
53647 int res1 = 0 ;
53648 void *argp2 = 0 ;
53649 int res2 = 0 ;
53650 int temp3 ;
53651 int res3 = SWIG_TMPOBJ ;
53652 PyObject * obj0 = 0 ;
53653 PyObject * obj1 = 0 ;
53654 char * kwnames[] = {
53655 (char *) "self",(char *) "win", NULL
53656 };
53657
53658 arg3 = &temp3;
53659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53661 if (!SWIG_IsOK(res1)) {
53662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53663 }
53664 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53665 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53666 if (!SWIG_IsOK(res2)) {
53667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53668 }
53669 arg2 = reinterpret_cast< wxWindow * >(argp2);
53670 {
53671 PyThreadState* __tstate = wxPyBeginAllowThreads();
53672 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53673 wxPyEndAllowThreads(__tstate);
53674 if (PyErr_Occurred()) SWIG_fail;
53675 }
53676 {
53677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53678 }
53679 if (SWIG_IsTmpObj(res3)) {
53680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53681 } else {
53682 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53684 }
53685 return resultobj;
53686 fail:
53687 return NULL;
53688 }
53689
53690
53691 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53692 PyObject *resultobj = 0;
53693 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53694 bool result;
53695 void *argp1 = 0 ;
53696 int res1 = 0 ;
53697 PyObject *swig_obj[1] ;
53698
53699 if (!args) SWIG_fail;
53700 swig_obj[0] = args;
53701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53702 if (!SWIG_IsOK(res1)) {
53703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53704 }
53705 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53706 {
53707 PyThreadState* __tstate = wxPyBeginAllowThreads();
53708 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53709 wxPyEndAllowThreads(__tstate);
53710 if (PyErr_Occurred()) SWIG_fail;
53711 }
53712 {
53713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53714 }
53715 return resultobj;
53716 fail:
53717 return NULL;
53718 }
53719
53720
53721 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53722 PyObject *obj;
53723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53724 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53725 return SWIG_Py_Void();
53726 }
53727
53728 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53729 return SWIG_Python_InitShadowInstance(args);
53730 }
53731
53732 static PyMethodDef SwigMethods[] = {
53733 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53734 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53735 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53736 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53737 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53738 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53739 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53740 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53741 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53743 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53754 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53755 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53756 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53758 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53759 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53760 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53761 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53762 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53763 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53764 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53766 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53772 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53773 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53774 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53775 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53776 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53777 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53778 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53780 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53788 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53789 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53790 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53795 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53796 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53798 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53800 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53802 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53804 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53806 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53808 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53809 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53811 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53813 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53814 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53815 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53816 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53836 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53837 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53838 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53839 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53840 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53841 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53842 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53843 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53845 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53846 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53847 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53852 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53853 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53854 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53855 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53862 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53869 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53870 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53871 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53872 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53874 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53875 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53876 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53878 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53879 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53880 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53881 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53886 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53887 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53888 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53889 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53890 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53891 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53894 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53895 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53896 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53898 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53899 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53901 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53902 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
53903 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53904 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53905 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53906 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53907 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53908 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53909 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53910 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53911 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53912 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53917 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53923 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53924 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53925 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53926 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53928 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53931 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53934 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53937 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53938 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53939 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53942 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53943 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53944 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53948 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53949 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53950 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53954 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53959 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53960 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53961 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53962 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53963 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53964 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53965 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53972 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53973 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53975 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53976 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53977 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53983 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53984 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53986 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53987 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53988 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53989 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53990 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53991 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53992 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53993 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53995 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53996 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53997 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53998 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53999 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54000 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54001 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54002 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54004 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54013 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54025 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54026 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54041 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54042 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54043 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54044 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54047 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54049 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54051 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54053 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54055 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54058 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54059 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54060 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54061 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54063 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54080 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54081 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54087 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54088 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54090 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54091 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54092 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54093 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54094 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54095 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54096 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54097 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54098 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54099 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54100 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54101 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54102 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54103 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54104 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54105 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54106 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54107 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54108 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54109 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54110 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54111 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54112 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54113 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54114 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54115 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54116 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54117 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54118 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54119 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54120 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54121 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54122 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54124 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54125 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54126 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54127 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54130 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54134 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54138 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54139 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54140 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54141 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54143 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54144 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54146 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54148 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54150 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54151 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54152 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54153 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54154 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54156 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54157 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54159 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54160 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54161 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54163 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54164 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54165 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54167 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54169 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54170 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54171 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54173 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54175 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54176 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54178 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54179 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54180 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54182 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54183 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54184 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54185 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54186 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54188 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54189 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54192 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54193 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54195 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54196 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54199 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54200 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54202 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54208 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54209 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54210 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54211 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54212 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54213 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54214 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54215 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54216 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54217 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54218 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54219 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54220 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54221 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54222 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54223 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54224 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54225 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54226 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54227 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54228 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54229 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54230 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54231 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54233 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54234 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54235 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54236 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54237 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54238 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54239 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54240 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54241 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54242 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54243 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54244 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54245 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54246 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54247 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54248 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54249 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54250 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54251 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54252 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54253 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54254 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54255 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54256 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54257 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54258 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54259 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54260 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54261 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54262 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54263 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54264 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54265 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54266 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54267 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54269 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54270 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54271 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54272 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54274 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54275 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54276 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54277 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54278 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54279 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54280 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54281 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54282 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54283 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54284 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54285 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54286 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54287 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54288 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54289 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54290 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54291 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54292 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54293 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54294 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54295 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54296 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54297 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54298 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54299 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54300 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54301 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54302 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54303 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54304 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54305 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54306 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54307 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54308 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54309 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54310 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54311 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54313 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54314 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54316 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54317 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54318 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54319 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54320 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54321 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54322 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54323 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54324 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54325 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54328 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54329 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54331 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54332 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54334 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54335 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54337 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54338 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54339 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54341 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54343 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54344 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54346 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54347 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54348 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54350 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54351 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54352 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54354 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54355 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54357 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54358 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54359 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54360 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54361 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54364 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54366 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54368 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54369 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54370 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54373 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54374 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54375 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54377 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54378 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54379 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54381 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54382 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54383 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54384 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54385 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54386 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54388 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54389 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54390 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54391 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54392 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54393 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54394 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54395 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54396 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54401 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54403 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54405 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54406 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54407 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54408 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54409 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54410 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54411 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54412 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54413 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54414 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54416 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54417 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54418 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54419 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54420 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54421 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54423 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54424 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54425 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54428 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54429 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54430 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54431 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54432 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54434 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54436 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54437 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54439 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54441 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54442 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54444 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54445 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54446 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54448 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54449 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54450 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54452 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54454 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54455 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54456 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54458 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54460 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54462 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54463 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54465 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54466 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54468 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54470 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54471 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54472 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54473 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54474 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54476 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54477 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54478 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54480 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54482 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54483 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54484 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54485 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54487 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54489 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54491 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54493 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54494 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54496 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54497 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54498 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54499 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54500 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54501 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54502 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54503 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54504 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54506 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54508 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54509 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54510 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54512 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54514 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54516 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54517 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54518 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54519 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54520 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54521 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54527 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54528 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54529 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54530 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54531 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54532 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54533 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54534 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54536 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54538 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54539 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54540 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54541 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54542 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54543 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54544 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54546 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54547 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54548 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54549 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54551 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54552 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54553 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54554 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54555 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54556 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54557 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54558 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54559 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54561 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54562 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54563 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54564 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54565 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54566 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54567 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54568 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54569 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54570 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54571 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54572 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54573 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54575 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54576 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54577 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54578 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54579 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54580 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54581 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54582 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54583 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54584 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54585 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54586 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54589 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54590 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54591 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54593 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54595 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54597 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54599 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54600 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54603 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54613 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54614 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54615 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54618 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54619 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54620 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54621 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54622 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54623 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54624 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54625 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54626 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54627 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54628 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54629 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54630 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54631 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54632 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54634 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54635 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54638 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54639 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54640 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54644 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54645 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54646 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54648 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54649 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54650 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54651 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54652 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54653 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54654 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54655 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54656 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54658 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54659 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54660 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54661 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54662 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
54663 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54664 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54665 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54666 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54667 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54668 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54669 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54672 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54673 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54674 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54675 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54676 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54677 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54678 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54679 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54680 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54681 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54682 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54683 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54684 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54685 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54686 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54687 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54688 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54689 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54690 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54691 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54692 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54693 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54695 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54697 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54698 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54699 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54700 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54701 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54702 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54703 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54705 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54706 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54707 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54708 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54712 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54713 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54714 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54715 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54716 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54717 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54718 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54719 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54720 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54721 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
54722 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54723 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54725 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54726 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54727 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54728 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54730 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54731 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54733 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54736 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54737 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54738 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54739 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54741 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54742 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54743 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54744 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54747 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54749 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54750 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54751 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54753 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54754 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54757 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54760 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54763 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54764 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54765 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54767 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54768 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54770 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54777 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54778 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54779 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54780 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54783 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54784 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54786 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54787 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54789 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54790 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54792 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54793 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54794 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54795 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54796 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54798 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54799 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54800 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54801 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54802 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54803 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54804 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54805 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54806 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54807 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54808 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54809 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54811 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54812 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54813 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54814 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54815 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54816 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54817 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54818 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54819 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54820 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54821 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54822 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54823 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54824 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54825 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54826 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54829 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54830 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54837 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54838 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54839 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54843 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54844 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54845 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54846 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54847 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54848 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54849 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54850 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54852 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54855 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54856 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54860 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54862 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54864 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54865 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54869 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54870 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54871 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54872 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54873 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54874 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54875 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54876 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54878 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54879 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54881 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54882 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54883 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54887 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54888 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54896 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54897 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54899 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54900 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54901 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54903 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54906 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54907 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54908 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54909 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54910 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54912 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54913 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54914 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54916 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54917 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54920 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54921 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54923 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54924 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54925 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54926 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54927 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54928 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54929 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54930 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54932 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54934 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54935 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54936 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54937 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54938 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54939 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54940 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54943 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54944 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54945 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54946 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54947 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54948 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54949 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54950 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54952 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54953 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54954 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54955 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54956 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54957 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54958 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54959 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54960 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54961 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54962 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54963 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54964 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54965 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54967 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54969 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54970 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54974 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54978 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54979 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54981 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54982 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54983 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54985 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54987 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54988 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54989 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54990 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54991 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54992 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54993 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54994 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54996 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54997 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54998 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54999 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55001 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55002 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55005 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55006 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55007 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55008 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55009 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55010 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55011 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55013 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55015 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55016 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55017 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55018 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55019 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55020 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55022 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55023 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55025 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55026 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55027 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55028 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55029 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55030 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55031 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55040 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55044 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55045 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55050 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55051 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55052 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55053 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55054 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55055 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55061 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55062 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55066 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55067 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55069 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55070 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55071 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55072 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55074 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55075 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55076 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55077 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55078 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55079 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55080 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55081 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55085 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55086 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55087 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55088 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55089 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55090 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55093 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55097 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55099 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55100 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55101 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55102 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55103 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55104 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55105 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55106 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55107 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55110 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55111 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55112 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55113 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55114 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55115 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55116 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55117 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55118 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55119 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55120 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55121 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55122 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55123 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55124 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55126 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55127 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55128 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55129 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55130 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55131 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55132 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55133 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55138 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55139 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55140 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55141 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55142 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55145 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55146 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55147 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55148 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55149 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55150 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55151 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55152 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55153 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55154 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55155 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55156 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55157 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55158 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55161 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55163 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55164 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55165 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55166 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55167 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55168 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55172 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55173 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55174 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55175 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55182 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55183 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55184 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55185 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55188 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55190 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55191 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55192 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55193 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55194 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55195 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55198 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55200 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55201 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55202 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55203 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55204 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55205 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55206 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55207 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55208 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55209 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55210 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55212 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55213 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55214 { NULL, NULL, 0, NULL }
55215 };
55216
55217
55218 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55219
55220 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55221 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55222 }
55223 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55224 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55225 }
55226 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55227 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55228 }
55229 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55230 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55231 }
55232 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55233 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55234 }
55235 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55236 return (void *)((wxSizer *) ((wxGridSizer *) x));
55237 }
55238 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55239 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55240 }
55241 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55242 return (void *)((wxSizer *) ((wxPySizer *) x));
55243 }
55244 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55245 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55246 }
55247 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55248 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55249 }
55250 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55251 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55252 }
55253 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55254 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55255 }
55256 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55257 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55258 }
55259 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55260 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55261 }
55262 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55263 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55264 }
55265 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55266 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55267 }
55268 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55269 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55270 }
55271 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55272 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55273 }
55274 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55275 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55276 }
55277 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55278 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55279 }
55280 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55281 return (void *)((wxEvent *) ((wxPyEvent *) x));
55282 }
55283 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55284 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55285 }
55286 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55287 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55288 }
55289 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55290 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55291 }
55292 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55293 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55294 }
55295 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55296 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55297 }
55298 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55299 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55300 }
55301 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55302 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55303 }
55304 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55305 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55306 }
55307 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55308 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55309 }
55310 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55311 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55312 }
55313 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55314 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55315 }
55316 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55317 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55318 }
55319 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55320 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55321 }
55322 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55323 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55324 }
55325 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55326 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55327 }
55328 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55329 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55330 }
55331 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55332 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55333 }
55334 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55335 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55336 }
55337 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55338 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55339 }
55340 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55341 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55342 }
55343 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55344 return (void *)((wxEvent *) ((wxShowEvent *) x));
55345 }
55346 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55347 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55348 }
55349 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55350 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55351 }
55352 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55353 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55354 }
55355 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55356 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55357 }
55358 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55359 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55360 }
55361 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55362 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55363 }
55364 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55365 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55366 }
55367 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55368 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55369 }
55370 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55371 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55372 }
55373 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55374 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55375 }
55376 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55377 return (void *)((wxControl *) ((wxControlWithItems *) x));
55378 }
55379 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55380 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55381 }
55382 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55383 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55384 }
55385 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55386 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55387 }
55388 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55389 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55390 }
55391 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55392 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55393 }
55394 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55395 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55396 }
55397 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55398 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55399 }
55400 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55401 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55402 }
55403 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55404 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55405 }
55406 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55407 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55408 }
55409 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55410 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55411 }
55412 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55413 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55414 }
55415 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55416 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55417 }
55418 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55419 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55420 }
55421 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55422 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55423 }
55424 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55425 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55426 }
55427 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55428 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55429 }
55430 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55431 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55432 }
55433 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55434 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55435 }
55436 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55437 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55438 }
55439 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55440 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55441 }
55442 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55443 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55444 }
55445 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55446 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55447 }
55448 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55449 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55450 }
55451 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55452 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55453 }
55454 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55455 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55456 }
55457 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55458 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55459 }
55460 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55461 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55462 }
55463 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55464 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55465 }
55466 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55467 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55468 }
55469 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55470 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55471 }
55472 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55473 return (void *)((wxObject *) ((wxSizerItem *) x));
55474 }
55475 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55476 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55477 }
55478 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55479 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55480 }
55481 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55482 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55483 }
55484 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55485 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55486 }
55487 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55488 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55489 }
55490 static void *_p_wxSizerTo_p_wxObject(void *x) {
55491 return (void *)((wxObject *) ((wxSizer *) x));
55492 }
55493 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55494 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55495 }
55496 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55497 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55498 }
55499 static void *_p_wxEventTo_p_wxObject(void *x) {
55500 return (void *)((wxObject *) ((wxEvent *) x));
55501 }
55502 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55503 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55504 }
55505 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55506 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55507 }
55508 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55509 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55510 }
55511 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55512 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55513 }
55514 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55515 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55516 }
55517 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55518 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55519 }
55520 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55521 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55522 }
55523 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55524 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55525 }
55526 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55527 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55528 }
55529 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55530 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55531 }
55532 static void *_p_wxControlTo_p_wxObject(void *x) {
55533 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55534 }
55535 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55536 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55537 }
55538 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55539 return (void *)((wxObject *) ((wxFSFile *) x));
55540 }
55541 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55542 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55543 }
55544 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55545 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55546 }
55547 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55548 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55549 }
55550 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55551 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55552 }
55553 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55554 return (void *)((wxObject *) ((wxMenuItem *) x));
55555 }
55556 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55557 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55558 }
55559 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55560 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55561 }
55562 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55563 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55564 }
55565 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55566 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55567 }
55568 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55569 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55570 }
55571 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55572 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55573 }
55574 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55575 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55576 }
55577 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55578 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55579 }
55580 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55581 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55582 }
55583 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55584 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55585 }
55586 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55587 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55588 }
55589 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55590 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55591 }
55592 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55593 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55594 }
55595 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55596 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55597 }
55598 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55599 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55600 }
55601 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55602 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55603 }
55604 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55605 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55606 }
55607 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55608 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55609 }
55610 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55611 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55612 }
55613 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55614 return (void *)((wxObject *) ((wxImageHandler *) x));
55615 }
55616 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55617 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55618 }
55619 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55620 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55621 }
55622 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55623 return (void *)((wxObject *) ((wxEvtHandler *) x));
55624 }
55625 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55626 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55627 }
55628 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55629 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55630 }
55631 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55632 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55633 }
55634 static void *_p_wxImageTo_p_wxObject(void *x) {
55635 return (void *)((wxObject *) ((wxImage *) x));
55636 }
55637 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55638 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55639 }
55640 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55641 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55642 }
55643 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55644 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55645 }
55646 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55647 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55648 }
55649 static void *_p_wxWindowTo_p_wxObject(void *x) {
55650 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55651 }
55652 static void *_p_wxMenuTo_p_wxObject(void *x) {
55653 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55654 }
55655 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55656 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55657 }
55658 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55659 return (void *)((wxObject *) ((wxFileSystem *) x));
55660 }
55661 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55662 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55663 }
55664 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55665 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55666 }
55667 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55668 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55669 }
55670 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55671 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55672 }
55673 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55674 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55675 }
55676 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55677 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55678 }
55679 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55680 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55681 }
55682 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55683 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55684 }
55685 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55686 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55687 }
55688 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55689 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55690 }
55691 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55692 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55693 }
55694 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55695 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55696 }
55697 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55698 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55699 }
55700 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55701 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55702 }
55703 static void *_p_wxControlTo_p_wxWindow(void *x) {
55704 return (void *)((wxWindow *) ((wxControl *) x));
55705 }
55706 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55707 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55708 }
55709 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55710 return (void *)((wxWindow *) ((wxMenuBar *) x));
55711 }
55712 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55713 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55714 }
55715 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55716 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55717 }
55718 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55719 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55720 }
55721 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55722 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55723 }
55724 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55725 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55726 }
55727 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55728 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55729 }
55730 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55731 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55732 }
55733 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55734 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55735 }
55736 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55737 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55738 }
55739 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55740 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55741 }
55742 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55743 return (void *)((wxValidator *) ((wxPyValidator *) x));
55744 }
55745 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55746 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55747 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};
55748 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55749 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55750 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55751 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55752 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55753 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55754 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55755 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55756 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55757 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55758 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55759 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55760 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55761 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55762 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55763 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55764 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55765 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55766 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55767 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55768 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55769 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55770 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55771 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55772 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55773 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55774 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55775 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55776 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55777 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55778 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55779 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55780 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55781 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55782 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55783 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55784 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55785 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55786 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55787 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55788 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55789 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55790 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55791 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55792 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55793 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55794 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55795 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55796 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55797 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55798 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55799 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55800 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55801 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55802 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55803 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55804 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55805 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55806 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55807 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55808 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55809 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55810 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55811 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55812 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55813 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55814 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55815 static swig_type_info _swigt__p_wxLayoutDirection = {"_p_wxLayoutDirection", "wxLayoutDirection *", 0, 0, (void*)0, 0};
55816 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55817 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55818 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55819 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55820 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55821 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55822 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55823 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55824 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55825 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55826 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55827 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55828 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55829 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55830 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55831 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55832 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55833 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55834 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55835 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55836 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55837 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55838 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55839 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55840 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55841 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55842 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55843 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55844 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55845 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55846 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55847 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55848 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55849 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55850 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55851 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55852 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55853 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55854 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55855 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55856 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55857 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55858 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55859 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55860 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55861 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55862 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55863 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55864 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55865 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55866 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55867 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55868 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55869 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55870 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55871 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55872 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55873 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55874 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55875 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55876 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55877 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55878
55879 static swig_type_info *swig_type_initial[] = {
55880 &_swigt__p_buffer,
55881 &_swigt__p_char,
55882 &_swigt__p_form_ops_t,
55883 &_swigt__p_int,
55884 &_swigt__p_long,
55885 &_swigt__p_unsigned_char,
55886 &_swigt__p_unsigned_int,
55887 &_swigt__p_unsigned_long,
55888 &_swigt__p_wxANIHandler,
55889 &_swigt__p_wxAcceleratorEntry,
55890 &_swigt__p_wxAcceleratorTable,
55891 &_swigt__p_wxActivateEvent,
55892 &_swigt__p_wxAppTraits,
55893 &_swigt__p_wxArrayString,
55894 &_swigt__p_wxBMPHandler,
55895 &_swigt__p_wxBitmap,
55896 &_swigt__p_wxBoxSizer,
55897 &_swigt__p_wxButton,
55898 &_swigt__p_wxCURHandler,
55899 &_swigt__p_wxCaret,
55900 &_swigt__p_wxChildFocusEvent,
55901 &_swigt__p_wxClipboardTextEvent,
55902 &_swigt__p_wxCloseEvent,
55903 &_swigt__p_wxColour,
55904 &_swigt__p_wxCommandEvent,
55905 &_swigt__p_wxContextMenuEvent,
55906 &_swigt__p_wxControl,
55907 &_swigt__p_wxControlWithItems,
55908 &_swigt__p_wxCursor,
55909 &_swigt__p_wxDC,
55910 &_swigt__p_wxDateEvent,
55911 &_swigt__p_wxDateTime,
55912 &_swigt__p_wxDisplayChangedEvent,
55913 &_swigt__p_wxDropFilesEvent,
55914 &_swigt__p_wxDuplexMode,
55915 &_swigt__p_wxEraseEvent,
55916 &_swigt__p_wxEvent,
55917 &_swigt__p_wxEventLoop,
55918 &_swigt__p_wxEventLoopActivator,
55919 &_swigt__p_wxEvtHandler,
55920 &_swigt__p_wxFSFile,
55921 &_swigt__p_wxFileSystem,
55922 &_swigt__p_wxFileSystemHandler,
55923 &_swigt__p_wxFlexGridSizer,
55924 &_swigt__p_wxFocusEvent,
55925 &_swigt__p_wxFont,
55926 &_swigt__p_wxFrame,
55927 &_swigt__p_wxGBPosition,
55928 &_swigt__p_wxGBSizerItem,
55929 &_swigt__p_wxGBSpan,
55930 &_swigt__p_wxGIFHandler,
55931 &_swigt__p_wxGridBagSizer,
55932 &_swigt__p_wxGridSizer,
55933 &_swigt__p_wxHelpEvent__Origin,
55934 &_swigt__p_wxICOHandler,
55935 &_swigt__p_wxIconizeEvent,
55936 &_swigt__p_wxIdleEvent,
55937 &_swigt__p_wxImage,
55938 &_swigt__p_wxImageHandler,
55939 &_swigt__p_wxImageHistogram,
55940 &_swigt__p_wxImage_HSVValue,
55941 &_swigt__p_wxImage_RGBValue,
55942 &_swigt__p_wxIndividualLayoutConstraint,
55943 &_swigt__p_wxInitDialogEvent,
55944 &_swigt__p_wxInputStream,
55945 &_swigt__p_wxInternetFSHandler,
55946 &_swigt__p_wxItemContainer,
55947 &_swigt__p_wxJPEGHandler,
55948 &_swigt__p_wxKeyEvent,
55949 &_swigt__p_wxLayoutConstraints,
55950 &_swigt__p_wxLayoutDirection,
55951 &_swigt__p_wxMaximizeEvent,
55952 &_swigt__p_wxMemoryFSHandler,
55953 &_swigt__p_wxMenu,
55954 &_swigt__p_wxMenuBar,
55955 &_swigt__p_wxMenuBarBase,
55956 &_swigt__p_wxMenuEvent,
55957 &_swigt__p_wxMenuItem,
55958 &_swigt__p_wxMouseCaptureChangedEvent,
55959 &_swigt__p_wxMouseCaptureLostEvent,
55960 &_swigt__p_wxMouseEvent,
55961 &_swigt__p_wxMoveEvent,
55962 &_swigt__p_wxNavigationKeyEvent,
55963 &_swigt__p_wxNcPaintEvent,
55964 &_swigt__p_wxNotifyEvent,
55965 &_swigt__p_wxObject,
55966 &_swigt__p_wxOutputStream,
55967 &_swigt__p_wxPCXHandler,
55968 &_swigt__p_wxPNGHandler,
55969 &_swigt__p_wxPNMHandler,
55970 &_swigt__p_wxPaintEvent,
55971 &_swigt__p_wxPaletteChangedEvent,
55972 &_swigt__p_wxPaperSize,
55973 &_swigt__p_wxPoint,
55974 &_swigt__p_wxPoint2D,
55975 &_swigt__p_wxPropagateOnce,
55976 &_swigt__p_wxPropagationDisabler,
55977 &_swigt__p_wxPyApp,
55978 &_swigt__p_wxPyCommandEvent,
55979 &_swigt__p_wxPyDropTarget,
55980 &_swigt__p_wxPyEvent,
55981 &_swigt__p_wxPyFileSystemHandler,
55982 &_swigt__p_wxPyImageHandler,
55983 &_swigt__p_wxPyInputStream,
55984 &_swigt__p_wxPySizer,
55985 &_swigt__p_wxPyValidator,
55986 &_swigt__p_wxQuantize,
55987 &_swigt__p_wxQueryNewPaletteEvent,
55988 &_swigt__p_wxRealPoint,
55989 &_swigt__p_wxRect,
55990 &_swigt__p_wxRegion,
55991 &_swigt__p_wxScrollEvent,
55992 &_swigt__p_wxScrollWinEvent,
55993 &_swigt__p_wxSetCursorEvent,
55994 &_swigt__p_wxShowEvent,
55995 &_swigt__p_wxSize,
55996 &_swigt__p_wxSizeEvent,
55997 &_swigt__p_wxSizer,
55998 &_swigt__p_wxSizerItem,
55999 &_swigt__p_wxStaticBox,
56000 &_swigt__p_wxStaticBoxSizer,
56001 &_swigt__p_wxStdDialogButtonSizer,
56002 &_swigt__p_wxSysColourChangedEvent,
56003 &_swigt__p_wxTIFFHandler,
56004 &_swigt__p_wxToolTip,
56005 &_swigt__p_wxUpdateUIEvent,
56006 &_swigt__p_wxValidator,
56007 &_swigt__p_wxVisualAttributes,
56008 &_swigt__p_wxWindow,
56009 &_swigt__p_wxWindowCreateEvent,
56010 &_swigt__p_wxWindowDestroyEvent,
56011 &_swigt__p_wxXPMHandler,
56012 &_swigt__p_wxZipFSHandler,
56013 };
56014
56015 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56016 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56017 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56018 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56019 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56020 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56021 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56022 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56023 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56024 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56025 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56026 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56027 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56028 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56029 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}};
56030 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56031 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}};
56032 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56033 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}};
56034 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56035 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56036 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56037 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56038 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56039 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}};
56040 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56041 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}};
56042 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56043 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56044 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56045 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56046 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56047 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56048 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56049 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56050 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56051 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
56052 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56053 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56054 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}};
56055 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56056 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56057 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}};
56058 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}};
56059 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56060 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56061 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56062 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56063 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56064 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56065 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56066 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56067 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}};
56068 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56069 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}};
56070 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56071 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56072 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56073 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}};
56074 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56075 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56076 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56077 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56078 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56079 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56080 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56081 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}};
56082 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56083 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56084 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56085 static swig_cast_info _swigc__p_wxLayoutDirection[] = { {&_swigt__p_wxLayoutDirection, 0, 0, 0},{0, 0, 0, 0}};
56086 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56087 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56088 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56089 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56090 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56091 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56092 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56093 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56094 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56095 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56096 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56097 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56098 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56099 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56100 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56101 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56102 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56103 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56104 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56105 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56106 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56107 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56108 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56109 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56110 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56111 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56112 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56113 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56114 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56115 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56116 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56117 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56118 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56119 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56120 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56121 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56122 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56123 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56124 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56125 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56126 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56127 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56128 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56129 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56130 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56131 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56132 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}};
56133 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}};
56134 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56135 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56136 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56137 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56138 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56139 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56140 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56141 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}};
56142 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56143 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}};
56144 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56145 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56146 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56147 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56148
56149 static swig_cast_info *swig_cast_initial[] = {
56150 _swigc__p_buffer,
56151 _swigc__p_char,
56152 _swigc__p_form_ops_t,
56153 _swigc__p_int,
56154 _swigc__p_long,
56155 _swigc__p_unsigned_char,
56156 _swigc__p_unsigned_int,
56157 _swigc__p_unsigned_long,
56158 _swigc__p_wxANIHandler,
56159 _swigc__p_wxAcceleratorEntry,
56160 _swigc__p_wxAcceleratorTable,
56161 _swigc__p_wxActivateEvent,
56162 _swigc__p_wxAppTraits,
56163 _swigc__p_wxArrayString,
56164 _swigc__p_wxBMPHandler,
56165 _swigc__p_wxBitmap,
56166 _swigc__p_wxBoxSizer,
56167 _swigc__p_wxButton,
56168 _swigc__p_wxCURHandler,
56169 _swigc__p_wxCaret,
56170 _swigc__p_wxChildFocusEvent,
56171 _swigc__p_wxClipboardTextEvent,
56172 _swigc__p_wxCloseEvent,
56173 _swigc__p_wxColour,
56174 _swigc__p_wxCommandEvent,
56175 _swigc__p_wxContextMenuEvent,
56176 _swigc__p_wxControl,
56177 _swigc__p_wxControlWithItems,
56178 _swigc__p_wxCursor,
56179 _swigc__p_wxDC,
56180 _swigc__p_wxDateEvent,
56181 _swigc__p_wxDateTime,
56182 _swigc__p_wxDisplayChangedEvent,
56183 _swigc__p_wxDropFilesEvent,
56184 _swigc__p_wxDuplexMode,
56185 _swigc__p_wxEraseEvent,
56186 _swigc__p_wxEvent,
56187 _swigc__p_wxEventLoop,
56188 _swigc__p_wxEventLoopActivator,
56189 _swigc__p_wxEvtHandler,
56190 _swigc__p_wxFSFile,
56191 _swigc__p_wxFileSystem,
56192 _swigc__p_wxFileSystemHandler,
56193 _swigc__p_wxFlexGridSizer,
56194 _swigc__p_wxFocusEvent,
56195 _swigc__p_wxFont,
56196 _swigc__p_wxFrame,
56197 _swigc__p_wxGBPosition,
56198 _swigc__p_wxGBSizerItem,
56199 _swigc__p_wxGBSpan,
56200 _swigc__p_wxGIFHandler,
56201 _swigc__p_wxGridBagSizer,
56202 _swigc__p_wxGridSizer,
56203 _swigc__p_wxHelpEvent__Origin,
56204 _swigc__p_wxICOHandler,
56205 _swigc__p_wxIconizeEvent,
56206 _swigc__p_wxIdleEvent,
56207 _swigc__p_wxImage,
56208 _swigc__p_wxImageHandler,
56209 _swigc__p_wxImageHistogram,
56210 _swigc__p_wxImage_HSVValue,
56211 _swigc__p_wxImage_RGBValue,
56212 _swigc__p_wxIndividualLayoutConstraint,
56213 _swigc__p_wxInitDialogEvent,
56214 _swigc__p_wxInputStream,
56215 _swigc__p_wxInternetFSHandler,
56216 _swigc__p_wxItemContainer,
56217 _swigc__p_wxJPEGHandler,
56218 _swigc__p_wxKeyEvent,
56219 _swigc__p_wxLayoutConstraints,
56220 _swigc__p_wxLayoutDirection,
56221 _swigc__p_wxMaximizeEvent,
56222 _swigc__p_wxMemoryFSHandler,
56223 _swigc__p_wxMenu,
56224 _swigc__p_wxMenuBar,
56225 _swigc__p_wxMenuBarBase,
56226 _swigc__p_wxMenuEvent,
56227 _swigc__p_wxMenuItem,
56228 _swigc__p_wxMouseCaptureChangedEvent,
56229 _swigc__p_wxMouseCaptureLostEvent,
56230 _swigc__p_wxMouseEvent,
56231 _swigc__p_wxMoveEvent,
56232 _swigc__p_wxNavigationKeyEvent,
56233 _swigc__p_wxNcPaintEvent,
56234 _swigc__p_wxNotifyEvent,
56235 _swigc__p_wxObject,
56236 _swigc__p_wxOutputStream,
56237 _swigc__p_wxPCXHandler,
56238 _swigc__p_wxPNGHandler,
56239 _swigc__p_wxPNMHandler,
56240 _swigc__p_wxPaintEvent,
56241 _swigc__p_wxPaletteChangedEvent,
56242 _swigc__p_wxPaperSize,
56243 _swigc__p_wxPoint,
56244 _swigc__p_wxPoint2D,
56245 _swigc__p_wxPropagateOnce,
56246 _swigc__p_wxPropagationDisabler,
56247 _swigc__p_wxPyApp,
56248 _swigc__p_wxPyCommandEvent,
56249 _swigc__p_wxPyDropTarget,
56250 _swigc__p_wxPyEvent,
56251 _swigc__p_wxPyFileSystemHandler,
56252 _swigc__p_wxPyImageHandler,
56253 _swigc__p_wxPyInputStream,
56254 _swigc__p_wxPySizer,
56255 _swigc__p_wxPyValidator,
56256 _swigc__p_wxQuantize,
56257 _swigc__p_wxQueryNewPaletteEvent,
56258 _swigc__p_wxRealPoint,
56259 _swigc__p_wxRect,
56260 _swigc__p_wxRegion,
56261 _swigc__p_wxScrollEvent,
56262 _swigc__p_wxScrollWinEvent,
56263 _swigc__p_wxSetCursorEvent,
56264 _swigc__p_wxShowEvent,
56265 _swigc__p_wxSize,
56266 _swigc__p_wxSizeEvent,
56267 _swigc__p_wxSizer,
56268 _swigc__p_wxSizerItem,
56269 _swigc__p_wxStaticBox,
56270 _swigc__p_wxStaticBoxSizer,
56271 _swigc__p_wxStdDialogButtonSizer,
56272 _swigc__p_wxSysColourChangedEvent,
56273 _swigc__p_wxTIFFHandler,
56274 _swigc__p_wxToolTip,
56275 _swigc__p_wxUpdateUIEvent,
56276 _swigc__p_wxValidator,
56277 _swigc__p_wxVisualAttributes,
56278 _swigc__p_wxWindow,
56279 _swigc__p_wxWindowCreateEvent,
56280 _swigc__p_wxWindowDestroyEvent,
56281 _swigc__p_wxXPMHandler,
56282 _swigc__p_wxZipFSHandler,
56283 };
56284
56285
56286 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56287
56288 static swig_const_info swig_const_table[] = {
56289 {0, 0, 0, 0.0, 0, 0}};
56290
56291 #ifdef __cplusplus
56292 }
56293 #endif
56294 /* -----------------------------------------------------------------------------
56295 * Type initialization:
56296 * This problem is tough by the requirement that no dynamic
56297 * memory is used. Also, since swig_type_info structures store pointers to
56298 * swig_cast_info structures and swig_cast_info structures store pointers back
56299 * to swig_type_info structures, we need some lookup code at initialization.
56300 * The idea is that swig generates all the structures that are needed.
56301 * The runtime then collects these partially filled structures.
56302 * The SWIG_InitializeModule function takes these initial arrays out of
56303 * swig_module, and does all the lookup, filling in the swig_module.types
56304 * array with the correct data and linking the correct swig_cast_info
56305 * structures together.
56306 *
56307 * The generated swig_type_info structures are assigned staticly to an initial
56308 * array. We just loop though that array, and handle each type individually.
56309 * First we lookup if this type has been already loaded, and if so, use the
56310 * loaded structure instead of the generated one. Then we have to fill in the
56311 * cast linked list. The cast data is initially stored in something like a
56312 * two-dimensional array. Each row corresponds to a type (there are the same
56313 * number of rows as there are in the swig_type_initial array). Each entry in
56314 * a column is one of the swig_cast_info structures for that type.
56315 * The cast_initial array is actually an array of arrays, because each row has
56316 * a variable number of columns. So to actually build the cast linked list,
56317 * we find the array of casts associated with the type, and loop through it
56318 * adding the casts to the list. The one last trick we need to do is making
56319 * sure the type pointer in the swig_cast_info struct is correct.
56320 *
56321 * First off, we lookup the cast->type name to see if it is already loaded.
56322 * There are three cases to handle:
56323 * 1) If the cast->type has already been loaded AND the type we are adding
56324 * casting info to has not been loaded (it is in this module), THEN we
56325 * replace the cast->type pointer with the type pointer that has already
56326 * been loaded.
56327 * 2) If BOTH types (the one we are adding casting info to, and the
56328 * cast->type) are loaded, THEN the cast info has already been loaded by
56329 * the previous module so we just ignore it.
56330 * 3) Finally, if cast->type has not already been loaded, then we add that
56331 * swig_cast_info to the linked list (because the cast->type) pointer will
56332 * be correct.
56333 * ----------------------------------------------------------------------------- */
56334
56335 #ifdef __cplusplus
56336 extern "C" {
56337 #if 0
56338 } /* c-mode */
56339 #endif
56340 #endif
56341
56342 #if 0
56343 #define SWIGRUNTIME_DEBUG
56344 #endif
56345
56346 SWIGRUNTIME void
56347 SWIG_InitializeModule(void *clientdata) {
56348 size_t i;
56349 swig_module_info *module_head;
56350 static int init_run = 0;
56351
56352 clientdata = clientdata;
56353
56354 if (init_run) return;
56355 init_run = 1;
56356
56357 /* Initialize the swig_module */
56358 swig_module.type_initial = swig_type_initial;
56359 swig_module.cast_initial = swig_cast_initial;
56360
56361 /* Try and load any already created modules */
56362 module_head = SWIG_GetModule(clientdata);
56363 if (module_head) {
56364 swig_module.next = module_head->next;
56365 module_head->next = &swig_module;
56366 } else {
56367 /* This is the first module loaded */
56368 swig_module.next = &swig_module;
56369 SWIG_SetModule(clientdata, &swig_module);
56370 }
56371
56372 /* Now work on filling in swig_module.types */
56373 #ifdef SWIGRUNTIME_DEBUG
56374 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56375 #endif
56376 for (i = 0; i < swig_module.size; ++i) {
56377 swig_type_info *type = 0;
56378 swig_type_info *ret;
56379 swig_cast_info *cast;
56380
56381 #ifdef SWIGRUNTIME_DEBUG
56382 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56383 #endif
56384
56385 /* if there is another module already loaded */
56386 if (swig_module.next != &swig_module) {
56387 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56388 }
56389 if (type) {
56390 /* Overwrite clientdata field */
56391 #ifdef SWIGRUNTIME_DEBUG
56392 printf("SWIG_InitializeModule: found type %s\n", type->name);
56393 #endif
56394 if (swig_module.type_initial[i]->clientdata) {
56395 type->clientdata = swig_module.type_initial[i]->clientdata;
56396 #ifdef SWIGRUNTIME_DEBUG
56397 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56398 #endif
56399 }
56400 } else {
56401 type = swig_module.type_initial[i];
56402 }
56403
56404 /* Insert casting types */
56405 cast = swig_module.cast_initial[i];
56406 while (cast->type) {
56407 /* Don't need to add information already in the list */
56408 ret = 0;
56409 #ifdef SWIGRUNTIME_DEBUG
56410 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56411 #endif
56412 if (swig_module.next != &swig_module) {
56413 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56414 #ifdef SWIGRUNTIME_DEBUG
56415 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56416 #endif
56417 }
56418 if (ret) {
56419 if (type == swig_module.type_initial[i]) {
56420 #ifdef SWIGRUNTIME_DEBUG
56421 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56422 #endif
56423 cast->type = ret;
56424 ret = 0;
56425 } else {
56426 /* Check for casting already in the list */
56427 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56428 #ifdef SWIGRUNTIME_DEBUG
56429 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56430 #endif
56431 if (!ocast) ret = 0;
56432 }
56433 }
56434
56435 if (!ret) {
56436 #ifdef SWIGRUNTIME_DEBUG
56437 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56438 #endif
56439 if (type->cast) {
56440 type->cast->prev = cast;
56441 cast->next = type->cast;
56442 }
56443 type->cast = cast;
56444 }
56445 cast++;
56446 }
56447 /* Set entry in modules->types array equal to the type */
56448 swig_module.types[i] = type;
56449 }
56450 swig_module.types[i] = 0;
56451
56452 #ifdef SWIGRUNTIME_DEBUG
56453 printf("**** SWIG_InitializeModule: Cast List ******\n");
56454 for (i = 0; i < swig_module.size; ++i) {
56455 int j = 0;
56456 swig_cast_info *cast = swig_module.cast_initial[i];
56457 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56458 while (cast->type) {
56459 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56460 cast++;
56461 ++j;
56462 }
56463 printf("---- Total casts: %d\n",j);
56464 }
56465 printf("**** SWIG_InitializeModule: Cast List ******\n");
56466 #endif
56467 }
56468
56469 /* This function will propagate the clientdata field of type to
56470 * any new swig_type_info structures that have been added into the list
56471 * of equivalent types. It is like calling
56472 * SWIG_TypeClientData(type, clientdata) a second time.
56473 */
56474 SWIGRUNTIME void
56475 SWIG_PropagateClientData(void) {
56476 size_t i;
56477 swig_cast_info *equiv;
56478 static int init_run = 0;
56479
56480 if (init_run) return;
56481 init_run = 1;
56482
56483 for (i = 0; i < swig_module.size; i++) {
56484 if (swig_module.types[i]->clientdata) {
56485 equiv = swig_module.types[i]->cast;
56486 while (equiv) {
56487 if (!equiv->converter) {
56488 if (equiv->type && !equiv->type->clientdata)
56489 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56490 }
56491 equiv = equiv->next;
56492 }
56493 }
56494 }
56495 }
56496
56497 #ifdef __cplusplus
56498 #if 0
56499 {
56500 /* c-mode */
56501 #endif
56502 }
56503 #endif
56504
56505
56506
56507 #ifdef __cplusplus
56508 extern "C" {
56509 #endif
56510
56511 /* Python-specific SWIG API */
56512 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56513 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56514 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56515
56516 /* -----------------------------------------------------------------------------
56517 * global variable support code.
56518 * ----------------------------------------------------------------------------- */
56519
56520 typedef struct swig_globalvar {
56521 char *name; /* Name of global variable */
56522 PyObject *(*get_attr)(void); /* Return the current value */
56523 int (*set_attr)(PyObject *); /* Set the value */
56524 struct swig_globalvar *next;
56525 } swig_globalvar;
56526
56527 typedef struct swig_varlinkobject {
56528 PyObject_HEAD
56529 swig_globalvar *vars;
56530 } swig_varlinkobject;
56531
56532 SWIGINTERN PyObject *
56533 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56534 return PyString_FromString("<Swig global variables>");
56535 }
56536
56537 SWIGINTERN PyObject *
56538 swig_varlink_str(swig_varlinkobject *v) {
56539 PyObject *str = PyString_FromString("(");
56540 swig_globalvar *var;
56541 for (var = v->vars; var; var=var->next) {
56542 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56543 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56544 }
56545 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56546 return str;
56547 }
56548
56549 SWIGINTERN int
56550 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56551 PyObject *str = swig_varlink_str(v);
56552 fprintf(fp,"Swig global variables ");
56553 fprintf(fp,"%s\n", PyString_AsString(str));
56554 Py_DECREF(str);
56555 return 0;
56556 }
56557
56558 SWIGINTERN void
56559 swig_varlink_dealloc(swig_varlinkobject *v) {
56560 swig_globalvar *var = v->vars;
56561 while (var) {
56562 swig_globalvar *n = var->next;
56563 free(var->name);
56564 free(var);
56565 var = n;
56566 }
56567 }
56568
56569 SWIGINTERN PyObject *
56570 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56571 PyObject *res = NULL;
56572 swig_globalvar *var = v->vars;
56573 while (var) {
56574 if (strcmp(var->name,n) == 0) {
56575 res = (*var->get_attr)();
56576 break;
56577 }
56578 var = var->next;
56579 }
56580 if (res == NULL && !PyErr_Occurred()) {
56581 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56582 }
56583 return res;
56584 }
56585
56586 SWIGINTERN int
56587 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56588 int res = 1;
56589 swig_globalvar *var = v->vars;
56590 while (var) {
56591 if (strcmp(var->name,n) == 0) {
56592 res = (*var->set_attr)(p);
56593 break;
56594 }
56595 var = var->next;
56596 }
56597 if (res == 1 && !PyErr_Occurred()) {
56598 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56599 }
56600 return res;
56601 }
56602
56603 SWIGINTERN PyTypeObject*
56604 swig_varlink_type(void) {
56605 static char varlink__doc__[] = "Swig var link object";
56606 static PyTypeObject varlink_type;
56607 static int type_init = 0;
56608 if (!type_init) {
56609 const PyTypeObject tmp
56610 = {
56611 PyObject_HEAD_INIT(NULL)
56612 0, /* Number of items in variable part (ob_size) */
56613 (char *)"swigvarlink", /* Type name (tp_name) */
56614 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56615 0, /* Itemsize (tp_itemsize) */
56616 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56617 (printfunc) swig_varlink_print, /* Print (tp_print) */
56618 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56619 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56620 0, /* tp_compare */
56621 (reprfunc) swig_varlink_repr, /* tp_repr */
56622 0, /* tp_as_number */
56623 0, /* tp_as_sequence */
56624 0, /* tp_as_mapping */
56625 0, /* tp_hash */
56626 0, /* tp_call */
56627 (reprfunc)swig_varlink_str, /* tp_str */
56628 0, /* tp_getattro */
56629 0, /* tp_setattro */
56630 0, /* tp_as_buffer */
56631 0, /* tp_flags */
56632 varlink__doc__, /* tp_doc */
56633 0, /* tp_traverse */
56634 0, /* tp_clear */
56635 0, /* tp_richcompare */
56636 0, /* tp_weaklistoffset */
56637 #if PY_VERSION_HEX >= 0x02020000
56638 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56639 #endif
56640 #if PY_VERSION_HEX >= 0x02030000
56641 0, /* tp_del */
56642 #endif
56643 #ifdef COUNT_ALLOCS
56644 0,0,0,0 /* tp_alloc -> tp_next */
56645 #endif
56646 };
56647 varlink_type = tmp;
56648 varlink_type.ob_type = &PyType_Type;
56649 type_init = 1;
56650 }
56651 return &varlink_type;
56652 }
56653
56654 /* Create a variable linking object for use later */
56655 SWIGINTERN PyObject *
56656 SWIG_Python_newvarlink(void) {
56657 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56658 if (result) {
56659 result->vars = 0;
56660 }
56661 return ((PyObject*) result);
56662 }
56663
56664 SWIGINTERN void
56665 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56666 swig_varlinkobject *v = (swig_varlinkobject *) p;
56667 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56668 if (gv) {
56669 size_t size = strlen(name)+1;
56670 gv->name = (char *)malloc(size);
56671 if (gv->name) {
56672 strncpy(gv->name,name,size);
56673 gv->get_attr = get_attr;
56674 gv->set_attr = set_attr;
56675 gv->next = v->vars;
56676 }
56677 }
56678 v->vars = gv;
56679 }
56680
56681 SWIGINTERN PyObject *
56682 SWIG_globals() {
56683 static PyObject *_SWIG_globals = 0;
56684 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56685 return _SWIG_globals;
56686 }
56687
56688 /* -----------------------------------------------------------------------------
56689 * constants/methods manipulation
56690 * ----------------------------------------------------------------------------- */
56691
56692 /* Install Constants */
56693 SWIGINTERN void
56694 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56695 PyObject *obj = 0;
56696 size_t i;
56697 for (i = 0; constants[i].type; ++i) {
56698 switch(constants[i].type) {
56699 case SWIG_PY_POINTER:
56700 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56701 break;
56702 case SWIG_PY_BINARY:
56703 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56704 break;
56705 default:
56706 obj = 0;
56707 break;
56708 }
56709 if (obj) {
56710 PyDict_SetItemString(d, constants[i].name, obj);
56711 Py_DECREF(obj);
56712 }
56713 }
56714 }
56715
56716 /* -----------------------------------------------------------------------------*/
56717 /* Fix SwigMethods to carry the callback ptrs when needed */
56718 /* -----------------------------------------------------------------------------*/
56719
56720 SWIGINTERN void
56721 SWIG_Python_FixMethods(PyMethodDef *methods,
56722 swig_const_info *const_table,
56723 swig_type_info **types,
56724 swig_type_info **types_initial) {
56725 size_t i;
56726 for (i = 0; methods[i].ml_name; ++i) {
56727 const char *c = methods[i].ml_doc;
56728 if (c && (c = strstr(c, "swig_ptr: "))) {
56729 int j;
56730 swig_const_info *ci = 0;
56731 const char *name = c + 10;
56732 for (j = 0; const_table[j].type; ++j) {
56733 if (strncmp(const_table[j].name, name,
56734 strlen(const_table[j].name)) == 0) {
56735 ci = &(const_table[j]);
56736 break;
56737 }
56738 }
56739 if (ci) {
56740 size_t shift = (ci->ptype) - types;
56741 swig_type_info *ty = types_initial[shift];
56742 size_t ldoc = (c - methods[i].ml_doc);
56743 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56744 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56745 if (ndoc) {
56746 char *buff = ndoc;
56747 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56748 if (ptr) {
56749 strncpy(buff, methods[i].ml_doc, ldoc);
56750 buff += ldoc;
56751 strncpy(buff, "swig_ptr: ", 10);
56752 buff += 10;
56753 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56754 methods[i].ml_doc = ndoc;
56755 }
56756 }
56757 }
56758 }
56759 }
56760 }
56761
56762 #ifdef __cplusplus
56763 }
56764 #endif
56765
56766 /* -----------------------------------------------------------------------------*
56767 * Partial Init method
56768 * -----------------------------------------------------------------------------*/
56769
56770 #ifdef __cplusplus
56771 extern "C"
56772 #endif
56773 SWIGEXPORT void SWIG_init(void) {
56774 PyObject *m, *d;
56775
56776 /* Fix SwigMethods to carry the callback ptrs when needed */
56777 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56778
56779 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56780 d = PyModule_GetDict(m);
56781
56782 SWIG_InitializeModule(0);
56783 SWIG_InstallConstants(d,swig_const_table);
56784
56785
56786
56787 #ifndef wxPyUSE_EXPORT
56788 // Make our API structure a CObject so other modules can import it
56789 // from this module.
56790 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56791 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56792 Py_XDECREF(cobj);
56793 #endif
56794
56795 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56796 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56797 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56798 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56799 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56800 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56801 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56802 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56803 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56804 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56805 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56806 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56807 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56808 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56809 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56810 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56811 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56812 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56813 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56814 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56815 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56816 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56817 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56818 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56819 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56820 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56821 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56822 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56823 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56824 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56825 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56826 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56827 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56828 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56829 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56830 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56831 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56832 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56833 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56834 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56835 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56836 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56837 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56838 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56839 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56840 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56841 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56842 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56843 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56844 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56845 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56846 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56847 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56848 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56849 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56850 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56851 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56852 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56853 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56854 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56855 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56856 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56857 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56858 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56859 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56860 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56861 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56862 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56863 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56864 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56865 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56866 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56867 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56868 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56869 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56870 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56871 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56872 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56873 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56874 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56875 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56876 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56877 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56878 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56879 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56880 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56881 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56882 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56883 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56884 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56885 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56886 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56887 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56888 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56889 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56890 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56891 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56892 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56893 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56894 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56895 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56896 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56897 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56898 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56899 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56900 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56901 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56902 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56903 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56904 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56905 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56906 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56907 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56908 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56909 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56910 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56911 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56912 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56913 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56914 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56915 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56916 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56917 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56918 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56919 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56920 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
56921 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56922 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56923 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56924 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56925 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56926 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56927 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56928 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56929 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56930 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56931 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56932 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56933 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56934 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56935 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56936 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56937 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56938 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56939 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56940 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
56941 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56942 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56943 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56944 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56945 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56946 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56947 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56948 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56949 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56950 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56951 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56952 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56953 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56954 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56955 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56956 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56957 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56958 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56959 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56960 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56961 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56962 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56963 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56964 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56965 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56966 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56967 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56968 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56969 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56970 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56971 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56972 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56973 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56974 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56975 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56976 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56977 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56978 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56979 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56980 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56981 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56982 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56983 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56984 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56985 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56986 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56987 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56988 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56989 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56990 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56991 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56992 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56993 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56994 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56995 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56996 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56997 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56998 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56999 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57000 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57001 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57002 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57003 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57004 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57005 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57006 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57007 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57008 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57009 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57010 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57011 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57012 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57013 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57014 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57015 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57016 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57017 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57018 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57019 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57020 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57021 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57022 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57023 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57024 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57025 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57026 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57027 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57028 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57029 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57030 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57031 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57032 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57033 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57034 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57035 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57036 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57037 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57038 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57039 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57040 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57041 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57042 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57043 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57044 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57045 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57046 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57047 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57048 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57049 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57050 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57051 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57052 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57053 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57054 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57055 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57056 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57057 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57058 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57059 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57060 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57061 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57062 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57063 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57064 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57065 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57066 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57067 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57068 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57069 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57070 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57071 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57072 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57073 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57074 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57075 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57076 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57077 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57078 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57079 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57080 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57081 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57082 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57083 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57084 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57085 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57086 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57087 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57088 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57089 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57090 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57091 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57092 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57093 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57094 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57095 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57096 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57097 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57098 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57099 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57100 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57101 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57102 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57103 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57104 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57105 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57106 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57107 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57108 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57109 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57110 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57111 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57112 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57113 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57114 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57115 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57116 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57117 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57118 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57119 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57120 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57121 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57122 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57123 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57124 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57125 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57126 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57127 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57128 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57129 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57130 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57131 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57132 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57133 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57134 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57135 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57136 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57137 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57138 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57139 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57140 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57141 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57142 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57143 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57144 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57145 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57146 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57147 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57148 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57149 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57150 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57151 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57152 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57153 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57154 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57155 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57156 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57157 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57158 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57159 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57160 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57161 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57162 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57163 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57164 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57165 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57166 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57167 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57168 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57169 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57170 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57171 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57172 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57173 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57174 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57175 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57176 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57177 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57178 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57179 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57180 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57181 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57182 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57183 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57184 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57185 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57186 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57187 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57188 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57189 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57190 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57191 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57192 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57193 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57194 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57195 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57196 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57197 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57198 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57199 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57200 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57201 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57202 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57203 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57204 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57205 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57206 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57207 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57208 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57209 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57210 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57211 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57212 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57213 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57214 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57215 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57216 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57217 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57218 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57219 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57220 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57221 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57222 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57223 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57224 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57225 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57226 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57227 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57228 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57229 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57230 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57231 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57232 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57233 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57234 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57235 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57236 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57237 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57238 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57239 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57240 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57241 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57242 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57243 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57244 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57245 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57246 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57247 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57248 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57249 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57250 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57251 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57252 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57253 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57254 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57255 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57256 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57257 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57258 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57259 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57260 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57261 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57262 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57263 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57264 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57265 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57266 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57267 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57268 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57269 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57270 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57271 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57272 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57273 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57274 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57275 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57276 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57277 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57278 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57279 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57280 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57281 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57282 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57283 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57284 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57285 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57286 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57287 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57288 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57289 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57290 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57291 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57292 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57293 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57294 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57295 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57296 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57297 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57298 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57299 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57300 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57301 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57302 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57303 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57304 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57305 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57306 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57307 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57308 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57309 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57310 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57311 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57312 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57313 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57314 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57315 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57316 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57317 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57318 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57319 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57320 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57321 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57322 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57323 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57324 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57325 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57326 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57327 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57328 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57329 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57330 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57331 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57332 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57333 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57334 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57335 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57336 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57337 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57338 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57339 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57340 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57341 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57342 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57343 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57344 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57345 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57346 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57347 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57348 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57349 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57350 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57351 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57352 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57353 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57354 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57355 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57356 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57357 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57358 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57359 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57360 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57361 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57362 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57363 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57364 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57365 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57366 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57367 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57368 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57369 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57370 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57371 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57372 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57373 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57374 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57375 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57376 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57377 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57378 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57379 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57380 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57381 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57382 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57383 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57384 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57385 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57386 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57387 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57388 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57389 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57390 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57391 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57392 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57393 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57394 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57395 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57396 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57397 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57398 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57399 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57400 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57401 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57402 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57403 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57404 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57405 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57406 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57407 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57408 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57409 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57410 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57411 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57412 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57413 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57414 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57415 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57416 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57417 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57418 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57419 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57420 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57421 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57422 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57423 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57424 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57425 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57426 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57427 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57428 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57429 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57430 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57431 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57432 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57433 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57434 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57435 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57436 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57437 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57438 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57439 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57440 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57441 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57442 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57443 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57444 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57445 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57446 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57447 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57448 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57449 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57450 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57451
57452 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57453
57454
57455 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57456
57457 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57458 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57459 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57460 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57461 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57462 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57463 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57464 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57465 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57466 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57467 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57468 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57469 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57470 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57471 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57472 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57473 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57474 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57475 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57476 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57477 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57478 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57479 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57480 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57481 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57482 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57483 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57484 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57485 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57486 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57487 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57488 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57489 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57490 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57491 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57492 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57493 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57494 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57495 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57496 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57497 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57498 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57499 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57500 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57501 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57502 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57503 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57504 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57505 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57506 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57507 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57508 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57509 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57510 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57511 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57512 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57513 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57514 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57515 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57516 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57517 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57518 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57519 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57520 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57521 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57522 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57523 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57524 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57525 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57526 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57527 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57528 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57529 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57530 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57531 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57532 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57533 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57534 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57535 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57536 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57537 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57538 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57539 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57540 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57541 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57542 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57543 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57544 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57545 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57546 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57547 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57548 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57549 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57550 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57551 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57552 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57553 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57554 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57555 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57556 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57557 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57558 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57559 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57560 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57561 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57562 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57563 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57564 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57565 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57566 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57567 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57568 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57569 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57570 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57571 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57572 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57573 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57574 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57575 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57576 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57577 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57578 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57579 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57580 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57581 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57582 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57583 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57584 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57585 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57586 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57587 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57588 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57589 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57590 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57591 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57592 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57593 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57594 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57595 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57596 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57597 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57598 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57599 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57600 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57601 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57602 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57603 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57604 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57605 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57606 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57607 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57608 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57609 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57610 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57611 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57612 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57613 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57614 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57615 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57616 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57617 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57618 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57619 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57620 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57621 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57622 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57623 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57624 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57625 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57626 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57627 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57628 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57629 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57630 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57631 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57632 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57633 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57634 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57635 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57636 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57637 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57638 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57639 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57640 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57641 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57642 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57643 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57644 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57645 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57646 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57647 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57648 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57649 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57650 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57651 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57652 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57653 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57654 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57655 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57656 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57657 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57658 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57659 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57660 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57661 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57662 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57663 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57664 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57665 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57666 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57667 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57668 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57669
57670 // Initialize threading, some globals and such
57671 __wxPyPreStart(d);
57672
57673
57674 // Although these are defined in __version__ they need to be here too so
57675 // that an assert can be done to ensure that the wxPython and the wxWindows
57676 // versions match.
57677 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57678 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57679 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57680
57681 }
57682
wxWidgets (Impactor)